From 4a9daa941016b71905ea64fdbbbf109168225615 Mon Sep 17 00:00:00 2001 From: SDKAuto Date: Fri, 21 Oct 2022 22:31:35 +0000 Subject: [PATCH] CodeGen from PR 20839 in Azure/azure-rest-api-specs Merge 232932c01264234b5b3ca4a94d8098ffaf9c0739 into 7b7f4b52c549d6ba62c387f569477ececf45f9f3 --- sdk/keyvault/azure-mgmt-keyvault/_meta.json | 12 +- .../azure/mgmt/keyvault/__init__.py | 4 + .../azure/mgmt/keyvault/_configuration.py | 12 +- .../keyvault/_key_vault_management_client.py | 26 +- .../azure/mgmt/keyvault/_serialization.py | 2006 +++++++++++++++++ .../azure/mgmt/keyvault/aio/_configuration.py | 4 +- .../aio/_key_vault_management_client.py | 17 +- .../mgmt/keyvault/v2016_10_01/__init__.py | 3 +- .../keyvault/v2016_10_01/_configuration.py | 42 +- .../_key_vault_management_client.py | 31 +- .../mgmt/keyvault/v2016_10_01/_metadata.json | 18 +- .../azure/mgmt/keyvault/v2016_10_01/_patch.py | 2 +- .../mgmt/keyvault/v2016_10_01/_vendor.py | 6 +- .../mgmt/keyvault/v2016_10_01/_version.py | 2 +- .../mgmt/keyvault/v2016_10_01/aio/__init__.py | 3 +- .../v2016_10_01/aio/_configuration.py | 44 +- .../aio/_key_vault_management_client.py | 31 +- .../mgmt/keyvault/v2016_10_01/aio/_patch.py | 2 +- .../v2016_10_01/aio/operations/__init__.py | 7 +- .../v2016_10_01/aio/operations/_operations.py | 71 +- .../v2016_10_01/aio/operations/_patch.py | 1 + .../aio/operations/_vaults_operations.py | 895 +++++--- .../keyvault/v2016_10_01/models/__init__.py | 92 +- .../_key_vault_management_client_enums.py | 38 +- .../v2016_10_01/models/_models_py3.py | 572 ++--- .../keyvault/v2016_10_01/models/_patch.py | 1 + .../v2016_10_01/operations/__init__.py | 7 +- .../v2016_10_01/operations/_operations.py | 98 +- .../keyvault/v2016_10_01/operations/_patch.py | 1 + .../operations/_vaults_operations.py | 1297 ++++++----- .../mgmt/keyvault/v2018_02_14/__init__.py | 3 +- .../keyvault/v2018_02_14/_configuration.py | 42 +- .../_key_vault_management_client.py | 38 +- .../mgmt/keyvault/v2018_02_14/_metadata.json | 18 +- .../azure/mgmt/keyvault/v2018_02_14/_patch.py | 2 +- .../mgmt/keyvault/v2018_02_14/_vendor.py | 6 +- .../mgmt/keyvault/v2018_02_14/_version.py | 2 +- .../mgmt/keyvault/v2018_02_14/aio/__init__.py | 3 +- .../v2018_02_14/aio/_configuration.py | 44 +- .../aio/_key_vault_management_client.py | 38 +- .../mgmt/keyvault/v2018_02_14/aio/_patch.py | 2 +- .../v2018_02_14/aio/operations/__init__.py | 11 +- .../v2018_02_14/aio/operations/_operations.py | 71 +- .../v2018_02_14/aio/operations/_patch.py | 1 + ...private_endpoint_connections_operations.py | 278 ++- .../_private_link_resources_operations.py | 53 +- .../aio/operations/_vaults_operations.py | 950 +++++--- .../keyvault/v2018_02_14/models/__init__.py | 128 +- .../_key_vault_management_client_enums.py | 48 +- .../v2018_02_14/models/_models_py3.py | 782 +++---- .../keyvault/v2018_02_14/models/_patch.py | 1 + .../v2018_02_14/operations/__init__.py | 11 +- .../v2018_02_14/operations/_operations.py | 98 +- .../keyvault/v2018_02_14/operations/_patch.py | 1 + ...private_endpoint_connections_operations.py | 386 ++-- .../_private_link_resources_operations.py | 89 +- .../operations/_vaults_operations.py | 1354 ++++++----- .../mgmt/keyvault/v2019_09_01/__init__.py | 3 +- .../keyvault/v2019_09_01/_configuration.py | 42 +- .../_key_vault_management_client.py | 43 +- .../mgmt/keyvault/v2019_09_01/_metadata.json | 18 +- .../azure/mgmt/keyvault/v2019_09_01/_patch.py | 2 +- .../mgmt/keyvault/v2019_09_01/_vendor.py | 6 +- .../mgmt/keyvault/v2019_09_01/_version.py | 2 +- .../mgmt/keyvault/v2019_09_01/aio/__init__.py | 3 +- .../v2019_09_01/aio/_configuration.py | 44 +- .../aio/_key_vault_management_client.py | 43 +- .../mgmt/keyvault/v2019_09_01/aio/_patch.py | 2 +- .../v2019_09_01/aio/operations/__init__.py | 13 +- .../aio/operations/_keys_operations.py | 372 +-- .../v2019_09_01/aio/operations/_operations.py | 71 +- .../v2019_09_01/aio/operations/_patch.py | 1 + ...private_endpoint_connections_operations.py | 278 ++- .../_private_link_resources_operations.py | 53 +- .../aio/operations/_vaults_operations.py | 950 +++++--- .../keyvault/v2019_09_01/models/__init__.py | 164 +- .../_key_vault_management_client_enums.py | 64 +- .../v2019_09_01/models/_models_py3.py | 1042 ++++----- .../keyvault/v2019_09_01/models/_patch.py | 1 + .../v2019_09_01/operations/__init__.py | 13 +- .../operations/_keys_operations.py | 560 ++--- .../v2019_09_01/operations/_operations.py | 98 +- .../keyvault/v2019_09_01/operations/_patch.py | 1 + ...private_endpoint_connections_operations.py | 386 ++-- .../_private_link_resources_operations.py | 89 +- .../operations/_vaults_operations.py | 1368 ++++++----- .../keyvault/v2020_04_01_preview/__init__.py | 3 +- .../v2020_04_01_preview/_configuration.py | 42 +- .../_key_vault_management_client.py | 53 +- .../v2020_04_01_preview/_metadata.json | 18 +- .../keyvault/v2020_04_01_preview/_patch.py | 2 +- .../keyvault/v2020_04_01_preview/_vendor.py | 6 +- .../keyvault/v2020_04_01_preview/_version.py | 2 +- .../v2020_04_01_preview/aio/__init__.py | 3 +- .../v2020_04_01_preview/aio/_configuration.py | 44 +- .../aio/_key_vault_management_client.py | 53 +- .../v2020_04_01_preview/aio/_patch.py | 2 +- .../aio/operations/__init__.py | 17 +- .../aio/operations/_keys_operations.py | 370 +-- .../operations/_managed_hsms_operations.py | 610 +++-- .../aio/operations/_operations.py | 71 +- .../aio/operations/_patch.py | 1 + ...private_endpoint_connections_operations.py | 279 ++- .../_private_link_resources_operations.py | 53 +- .../aio/operations/_secrets_operations.py | 372 ++- .../aio/operations/_vaults_operations.py | 950 +++++--- .../v2020_04_01_preview/models/__init__.py | 214 +- .../_key_vault_management_client_enums.py | 84 +- .../v2020_04_01_preview/models/_models_py3.py | 1360 +++++------ .../v2020_04_01_preview/models/_patch.py | 1 + .../operations/__init__.py | 17 +- .../operations/_keys_operations.py | 562 ++--- .../operations/_managed_hsms_operations.py | 833 +++---- .../operations/_operations.py | 98 +- .../v2020_04_01_preview/operations/_patch.py | 1 + ...private_endpoint_connections_operations.py | 387 ++-- .../_private_link_resources_operations.py | 89 +- .../operations/_secrets_operations.py | 531 +++-- .../operations/_vaults_operations.py | 1369 ++++++----- .../keyvault/v2021_04_01_preview/__init__.py | 3 +- .../v2021_04_01_preview/_configuration.py | 42 +- .../_key_vault_management_client.py | 45 +- .../v2021_04_01_preview/_metadata.json | 18 +- .../keyvault/v2021_04_01_preview/_patch.py | 2 +- .../keyvault/v2021_04_01_preview/_vendor.py | 6 +- .../keyvault/v2021_04_01_preview/_version.py | 2 +- .../v2021_04_01_preview/aio/__init__.py | 3 +- .../v2021_04_01_preview/aio/_configuration.py | 44 +- .../aio/_key_vault_management_client.py | 45 +- .../v2021_04_01_preview/aio/_patch.py | 2 +- .../aio/operations/__init__.py | 17 +- .../operations/_managed_hsms_operations.py | 796 ++++--- ...private_endpoint_connections_operations.py | 344 +-- ..._mhsm_private_link_resources_operations.py | 52 +- .../aio/operations/_operations.py | 71 +- .../aio/operations/_patch.py | 1 + ...private_endpoint_connections_operations.py | 348 +-- .../_private_link_resources_operations.py | 53 +- .../aio/operations/_vaults_operations.py | 950 +++++--- .../v2021_04_01_preview/models/__init__.py | 204 +- .../_key_vault_management_client_enums.py | 73 +- .../v2021_04_01_preview/models/_models_py3.py | 1386 ++++++------ .../v2021_04_01_preview/models/_patch.py | 1 + .../operations/__init__.py | 17 +- .../operations/_managed_hsms_operations.py | 1119 ++++----- ...private_endpoint_connections_operations.py | 503 +++-- ..._mhsm_private_link_resources_operations.py | 88 +- .../operations/_operations.py | 98 +- .../v2021_04_01_preview/operations/_patch.py | 1 + ...private_endpoint_connections_operations.py | 489 ++-- .../_private_link_resources_operations.py | 89 +- .../operations/_vaults_operations.py | 1369 ++++++----- .../keyvault/v2021_06_01_preview/__init__.py | 3 +- .../v2021_06_01_preview/_configuration.py | 42 +- .../_key_vault_management_client.py | 55 +- .../v2021_06_01_preview/_metadata.json | 18 +- .../keyvault/v2021_06_01_preview/_patch.py | 2 +- .../keyvault/v2021_06_01_preview/_vendor.py | 6 +- .../keyvault/v2021_06_01_preview/_version.py | 2 +- .../v2021_06_01_preview/aio/__init__.py | 3 +- .../v2021_06_01_preview/aio/_configuration.py | 44 +- .../aio/_key_vault_management_client.py | 55 +- .../v2021_06_01_preview/aio/_patch.py | 2 +- .../aio/operations/__init__.py | 21 +- .../aio/operations/_keys_operations.py | 370 +-- .../operations/_managed_hsms_operations.py | 796 ++++--- ...private_endpoint_connections_operations.py | 344 +-- ..._mhsm_private_link_resources_operations.py | 52 +- .../aio/operations/_operations.py | 71 +- .../aio/operations/_patch.py | 1 + ...private_endpoint_connections_operations.py | 348 +-- .../_private_link_resources_operations.py | 53 +- .../aio/operations/_secrets_operations.py | 372 ++- .../aio/operations/_vaults_operations.py | 944 +++++--- .../v2021_06_01_preview/models/__init__.py | 258 ++- .../_key_vault_management_client_enums.py | 77 +- .../v2021_06_01_preview/models/_models_py3.py | 1823 +++++++-------- .../v2021_06_01_preview/models/_patch.py | 1 + .../operations/__init__.py | 21 +- .../operations/_keys_operations.py | 562 ++--- .../operations/_managed_hsms_operations.py | 1119 ++++----- ...private_endpoint_connections_operations.py | 503 +++-- ..._mhsm_private_link_resources_operations.py | 88 +- .../operations/_operations.py | 98 +- .../v2021_06_01_preview/operations/_patch.py | 1 + ...private_endpoint_connections_operations.py | 489 ++-- .../_private_link_resources_operations.py | 89 +- .../operations/_secrets_operations.py | 531 +++-- .../operations/_vaults_operations.py | 1370 ++++++----- .../mgmt/keyvault/v2021_10_01/__init__.py | 3 +- .../keyvault/v2021_10_01/_configuration.py | 42 +- .../_key_vault_management_client.py | 55 +- .../mgmt/keyvault/v2021_10_01/_metadata.json | 18 +- .../azure/mgmt/keyvault/v2021_10_01/_patch.py | 2 +- .../mgmt/keyvault/v2021_10_01/_vendor.py | 6 +- .../mgmt/keyvault/v2021_10_01/_version.py | 2 +- .../mgmt/keyvault/v2021_10_01/aio/__init__.py | 3 +- .../v2021_10_01/aio/_configuration.py | 44 +- .../aio/_key_vault_management_client.py | 55 +- .../mgmt/keyvault/v2021_10_01/aio/_patch.py | 2 +- .../v2021_10_01/aio/operations/__init__.py | 21 +- .../aio/operations/_keys_operations.py | 378 ++-- .../operations/_managed_hsms_operations.py | 792 ++++--- ...private_endpoint_connections_operations.py | 345 +-- ..._mhsm_private_link_resources_operations.py | 52 +- .../v2021_10_01/aio/operations/_operations.py | 71 +- .../v2021_10_01/aio/operations/_patch.py | 1 + ...private_endpoint_connections_operations.py | 347 +-- .../_private_link_resources_operations.py | 53 +- .../aio/operations/_secrets_operations.py | 378 +++- .../aio/operations/_vaults_operations.py | 944 +++++--- .../keyvault/v2021_10_01/models/__init__.py | 242 +- .../_key_vault_management_client_enums.py | 73 +- .../v2021_10_01/models/_models_py3.py | 1721 +++++++------- .../keyvault/v2021_10_01/models/_patch.py | 1 + .../v2021_10_01/operations/__init__.py | 21 +- .../operations/_keys_operations.py | 566 ++--- .../operations/_managed_hsms_operations.py | 1118 ++++----- ...private_endpoint_connections_operations.py | 504 +++-- ..._mhsm_private_link_resources_operations.py | 88 +- .../v2021_10_01/operations/_operations.py | 98 +- .../keyvault/v2021_10_01/operations/_patch.py | 1 + ...private_endpoint_connections_operations.py | 488 ++-- .../_private_link_resources_operations.py | 89 +- .../operations/_secrets_operations.py | 535 +++-- .../operations/_vaults_operations.py | 1369 ++++++----- .../mgmt/keyvault/v2022_07_01/__init__.py | 3 +- .../keyvault/v2022_07_01/_configuration.py | 42 +- .../_key_vault_management_client.py | 55 +- .../mgmt/keyvault/v2022_07_01/_metadata.json | 18 +- .../azure/mgmt/keyvault/v2022_07_01/_patch.py | 1 + .../mgmt/keyvault/v2022_07_01/_vendor.py | 6 +- .../mgmt/keyvault/v2022_07_01/_version.py | 2 +- .../mgmt/keyvault/v2022_07_01/aio/__init__.py | 3 +- .../v2022_07_01/aio/_configuration.py | 44 +- .../aio/_key_vault_management_client.py | 55 +- .../mgmt/keyvault/v2022_07_01/aio/_patch.py | 1 + .../v2022_07_01/aio/operations/__init__.py | 21 +- .../aio/operations/_keys_operations.py | 378 ++-- .../operations/_managed_hsms_operations.py | 885 +++++--- ...private_endpoint_connections_operations.py | 343 +-- ..._mhsm_private_link_resources_operations.py | 52 +- .../v2022_07_01/aio/operations/_operations.py | 71 +- .../v2022_07_01/aio/operations/_patch.py | 1 + ...private_endpoint_connections_operations.py | 347 +-- .../_private_link_resources_operations.py | 53 +- .../aio/operations/_secrets_operations.py | 378 +++- .../aio/operations/_vaults_operations.py | 944 +++++--- .../keyvault/v2022_07_01/models/__init__.py | 268 ++- .../_key_vault_management_client_enums.py | 81 +- .../v2022_07_01/models/_models_py3.py | 1890 +++++++--------- .../keyvault/v2022_07_01/models/_patch.py | 1 + .../v2022_07_01/operations/__init__.py | 21 +- .../operations/_keys_operations.py | 566 ++--- .../operations/_managed_hsms_operations.py | 1254 ++++++----- ...private_endpoint_connections_operations.py | 502 +++-- ..._mhsm_private_link_resources_operations.py | 88 +- .../v2022_07_01/operations/_operations.py | 98 +- .../keyvault/v2022_07_01/operations/_patch.py | 1 + ...private_endpoint_connections_operations.py | 488 ++-- .../_private_link_resources_operations.py | 89 +- .../operations/_secrets_operations.py | 535 +++-- .../operations/_vaults_operations.py | 1369 ++++++----- 263 files changed, 36483 insertions(+), 27948 deletions(-) create mode 100644 sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_serialization.py diff --git a/sdk/keyvault/azure-mgmt-keyvault/_meta.json b/sdk/keyvault/azure-mgmt-keyvault/_meta.json index 599930fa425d..35aad0617426 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/_meta.json +++ b/sdk/keyvault/azure-mgmt-keyvault/_meta.json @@ -1,11 +1,11 @@ { - "autorest": "3.7.2", + "commit": "b5c1ce67c1dfb254ce45e61d82cfb796f957977c", + "repository_url": "https://github.com/Azure/azure-rest-api-specs", + "autorest": "3.9.2", "use": [ - "@autorest/python@5.16.0", - "@autorest/modelerfour@4.19.3" + "@autorest/python@6.1.11", + "@autorest/modelerfour@4.24.3" ], - "commit": "1b3b9c1dd4d2c875997ea0b392dc71418fb1f28d", - "repository_url": "https://github.com/Azure/azure-rest-api-specs", - "autorest_command": "autorest specification/keyvault/resource-manager/readme.md --python --python-sdks-folder=/home/vsts/work/1/azure-sdk-for-python/sdk --python3-only --use=@autorest/python@5.16.0 --use=@autorest/modelerfour@4.19.3 --version=3.7.2", + "autorest_command": "autorest specification/keyvault/resource-manager/readme.md --python --python-sdks-folder=/mnt/vss/_work/1/s/azure-sdk-for-python/sdk --use=@autorest/python@6.1.11 --use=@autorest/modelerfour@4.24.3 --version=3.9.2 --version-tolerant=False", "readme": "specification/keyvault/resource-manager/readme.md" } \ No newline at end of file diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/__init__.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/__init__.py index e03c4a3b857a..7d2c4d33d1be 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/__init__.py @@ -14,3 +14,7 @@ patch_sdk() except ImportError: pass + +from ._version import VERSION + +__version__ = VERSION diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_configuration.py index fc6aa7c043a1..be6c6051c695 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_configuration.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_configuration.py @@ -8,7 +8,7 @@ # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING +from typing import Any, TYPE_CHECKING from azure.core.configuration import Configuration from azure.core.pipeline import policies @@ -18,8 +18,6 @@ if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - from typing import Any - from azure.core.credentials import TokenCredential class KeyVaultManagementClientConfiguration(Configuration): @@ -28,16 +26,16 @@ class KeyVaultManagementClientConfiguration(Configuration): 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. + :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. + :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 """ def __init__( self, - credential, # type: "TokenCredential" - subscription_id, # type: str + credential: "TokenCredential", + subscription_id: str, **kwargs # type: Any ): # type: (...) -> None 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 aba855e16cb1..0c304d0d8a4a 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 @@ -9,20 +9,17 @@ # regenerated. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING - -from msrest import Deserializer, Serializer +from typing import Any, Optional, TYPE_CHECKING from azure.mgmt.core import ARMPipelineClient from azure.profiles import KnownProfiles, ProfileDefinition from azure.profiles.multiapiclient import MultiApiClientMixin from ._configuration import KeyVaultManagementClientConfiguration +from ._serialization import Deserializer, Serializer if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - from typing import Any, Optional - from azure.core.credentials import TokenCredential class _SDKClient(object): @@ -43,9 +40,9 @@ class KeyVaultManagementClient(MultiApiClientMixin, _SDKClient): The api-version parameter sets the default API version if the operation group is not described in the profile. - :param credential: Credential needed for the client to connect to Azure. + :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. + :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 api_version: API version to use if no profile is provided, or if missing in profile. :type api_version: str @@ -67,10 +64,10 @@ class KeyVaultManagementClient(MultiApiClientMixin, _SDKClient): def __init__( self, - credential, # type: "TokenCredential" - subscription_id, # type: str + credential: "TokenCredential", + subscription_id: str, api_version=None, # type: Optional[str] - base_url="https://management.azure.com", # type: str + base_url: str = "https://management.azure.com", profile=KnownProfiles.default, # type: KnownProfiles **kwargs # type: Any ): @@ -147,6 +144,7 @@ def keys(self): from .v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -172,6 +170,7 @@ def managed_hsms(self): from .v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -194,6 +193,7 @@ def mhsm_private_endpoint_connections(self): from .v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -216,6 +216,7 @@ def mhsm_private_link_resources(self): from .v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -250,6 +251,7 @@ def operations(self): from .v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -281,6 +283,7 @@ def private_endpoint_connections(self): from .v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -312,6 +315,7 @@ def private_link_resources(self): from .v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -334,6 +338,7 @@ def secrets(self): from .v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -368,6 +373,7 @@ def vaults(self): from .v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) def close(self): diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_serialization.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_serialization.py new file mode 100644 index 000000000000..240df16c57f3 --- /dev/null +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/_serialization.py @@ -0,0 +1,2006 @@ +# -------------------------------------------------------------------------- +# +# Copyright (c) Microsoft Corporation. All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the ""Software""), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. +# +# -------------------------------------------------------------------------- + +# pylint: skip-file + +from base64 import b64decode, b64encode +import calendar +import datetime +import decimal +import email +from enum import Enum +import json +import logging +import re +import sys +import codecs +try: + from urllib import quote # type: ignore +except ImportError: + from urllib.parse import quote # type: ignore +import xml.etree.ElementTree as ET + +import isodate + +from typing import Dict, Any, cast, TYPE_CHECKING + +from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback + +_BOM = codecs.BOM_UTF8.decode(encoding='utf-8') + +if TYPE_CHECKING: + from typing import Optional, Union, AnyStr, IO, Mapping + +class RawDeserializer: + + # Accept "text" because we're open minded people... + JSON_REGEXP = re.compile(r'^(application|text)/([a-z+.]+\+)?json$') + + # Name used in context + CONTEXT_NAME = "deserialized_data" + + @classmethod + def deserialize_from_text(cls, data, content_type=None): + # type: (Optional[Union[AnyStr, IO]], Optional[str]) -> Any + """Decode data according to content-type. + + Accept a stream of data as well, but will be load at once in memory for now. + + If no content-type, will return the string version (not bytes, not stream) + + :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. + """ + if hasattr(data, 'read'): + # Assume a stream + data = cast(IO, data).read() + + if isinstance(data, bytes): + data_as_str = data.decode(encoding='utf-8-sig') + else: + # Explain to mypy the correct type. + data_as_str = cast(str, data) + + # Remove Byte Order Mark if present in string + data_as_str = data_as_str.lstrip(_BOM) + + if content_type is None: + return data + + if cls.JSON_REGEXP.match(content_type): + try: + return json.loads(data_as_str) + except ValueError as err: + raise DeserializationError("JSON is invalid: {}".format(err), err) + elif "xml" in (content_type or []): + try: + + try: + if isinstance(data, unicode): # type: ignore + # If I'm Python 2.7 and unicode XML will scream if I try a "fromstring" on unicode string + data_as_str = data_as_str.encode(encoding="utf-8") # type: ignore + except NameError: + pass + + return ET.fromstring(data_as_str) # nosec + except ET.ParseError: + # It might be because the server has an issue, and returned JSON with + # content-type XML.... + # So let's try a JSON load, and if it's still broken + # let's flow the initial exception + def _json_attemp(data): + try: + return True, json.loads(data) + except ValueError: + return False, None # Don't care about this one + success, json_result = _json_attemp(data) + if success: + return json_result + # If i'm here, it's not JSON, it's not XML, let's scream + # and raise the last context in this block (the XML exception) + # The function hack is because Py2.7 messes up with exception + # context otherwise. + _LOGGER.critical("Wasn't XML not JSON, failing") + raise_with_traceback(DeserializationError, "XML is invalid") + raise DeserializationError("Cannot deserialize content-type: {}".format(content_type)) + + @classmethod + def deserialize_from_http_generics(cls, body_bytes, headers): + # type: (Optional[Union[AnyStr, IO]], Mapping) -> Any + """Deserialize from HTTP response. + + Use bytes and headers to NOT use any requests/aiohttp or whatever + specific implementation. + Headers will tested for "content-type" + """ + # Try to use content-type from headers if available + content_type = None + if 'content-type' in headers: + content_type = headers['content-type'].split(";")[0].strip().lower() + # Ouch, this server did not declare what it sent... + # Let's guess it's JSON... + # Also, since Autorest was considering that an empty body was a valid JSON, + # need that test as well.... + else: + content_type = "application/json" + + if body_bytes: + return cls.deserialize_from_text(body_bytes, content_type) + return None + +try: + basestring # type: ignore + unicode_str = unicode # type: ignore +except NameError: + basestring = str # type: ignore + unicode_str = str # type: ignore + +_LOGGER = logging.getLogger(__name__) + +try: + _long_type = long # type: ignore +except NameError: + _long_type = int + +class UTC(datetime.tzinfo): + """Time Zone info for handling UTC""" + + def utcoffset(self, dt): + """UTF offset for UTC is 0.""" + return datetime.timedelta(0) + + def tzname(self, dt): + """Timestamp representation.""" + return "Z" + + def dst(self, dt): + """No daylight saving for UTC.""" + return datetime.timedelta(hours=1) + +try: + from datetime import timezone as _FixedOffset +except ImportError: # Python 2.7 + class _FixedOffset(datetime.tzinfo): # type: ignore + """Fixed offset in minutes east from UTC. + Copy/pasted from Python doc + :param datetime.timedelta offset: offset in timedelta format + """ + + def __init__(self, offset): + self.__offset = offset + + def utcoffset(self, dt): + return self.__offset + + def tzname(self, dt): + return str(self.__offset.total_seconds()/3600) + + def __repr__(self): + return "".format(self.tzname(None)) + + def dst(self, dt): + return datetime.timedelta(0) + + def __getinitargs__(self): + return (self.__offset,) + +try: + from datetime import timezone + TZ_UTC = timezone.utc # type: ignore +except ImportError: + TZ_UTC = UTC() # type: ignore + +_FLATTEN = re.compile(r"(? y, + "minimum": lambda x, y: x < y, + "maximum": lambda x, y: x > y, + "minimum_ex": lambda x, y: x <= y, + "maximum_ex": lambda x, y: x >= y, + "min_items": lambda x, y: len(x) < y, + "max_items": lambda x, y: len(x) > y, + "pattern": lambda x, y: not re.match(y, x, re.UNICODE), + "unique": lambda x, y: len(x) != len(set(x)), + "multiple": lambda x, y: x % y != 0 + } + + def __init__(self, classes=None): + self.serialize_type = { + 'iso-8601': Serializer.serialize_iso, + 'rfc-1123': Serializer.serialize_rfc, + 'unix-time': Serializer.serialize_unix, + 'duration': Serializer.serialize_duration, + 'date': Serializer.serialize_date, + 'time': Serializer.serialize_time, + 'decimal': Serializer.serialize_decimal, + 'long': Serializer.serialize_long, + 'bytearray': Serializer.serialize_bytearray, + 'base64': Serializer.serialize_base64, + 'object': self.serialize_object, + '[]': self.serialize_iter, + '{}': self.serialize_dict + } + self.dependencies = dict(classes) if classes else {} + self.key_transformer = full_restapi_key_transformer + self.client_side_validation = True + + def _serialize(self, target_obj, data_type=None, **kwargs): + """Serialize data into a string according to type. + + :param 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. + """ + key_transformer = kwargs.get("key_transformer", self.key_transformer) + keep_readonly = kwargs.get("keep_readonly", False) + if target_obj is None: + return None + + attr_name = None + class_name = target_obj.__class__.__name__ + + if data_type: + return self.serialize_data( + target_obj, data_type, **kwargs) + + if not hasattr(target_obj, "_attribute_map"): + data_type = type(target_obj).__name__ + if data_type in self.basic_types.values(): + return self.serialize_data( + target_obj, data_type, **kwargs) + + # Force "is_xml" kwargs if we detect a XML model + try: + is_xml_model_serialization = kwargs["is_xml"] + except KeyError: + is_xml_model_serialization = kwargs.setdefault("is_xml", target_obj.is_xml_model()) + + serialized = {} + if is_xml_model_serialization: + serialized = target_obj._create_xml_node() + try: + attributes = target_obj._attribute_map + for attr, attr_desc in attributes.items(): + attr_name = attr + if not keep_readonly and target_obj._validation.get(attr_name, {}).get('readonly', False): + continue + + if attr_name == "additional_properties" and attr_desc["key"] == '': + if target_obj.additional_properties is not None: + serialized.update(target_obj.additional_properties) + continue + try: + + orig_attr = getattr(target_obj, attr) + if is_xml_model_serialization: + pass # Don't provide "transformer" for XML for now. Keep "orig_attr" + else: # JSON + keys, orig_attr = key_transformer(attr, attr_desc.copy(), orig_attr) + keys = keys if isinstance(keys, list) else [keys] + + + kwargs["serialization_ctxt"] = attr_desc + new_attr = self.serialize_data(orig_attr, attr_desc['type'], **kwargs) + + + if is_xml_model_serialization: + xml_desc = attr_desc.get('xml', {}) + xml_name = xml_desc.get('name', attr_desc['key']) + xml_prefix = xml_desc.get('prefix', None) + xml_ns = xml_desc.get('ns', None) + if xml_desc.get("attr", False): + if xml_ns: + ET.register_namespace(xml_prefix, xml_ns) + xml_name = "{}{}".format(xml_ns, xml_name) + serialized.set(xml_name, new_attr) + continue + if xml_desc.get("text", False): + serialized.text = new_attr + continue + if isinstance(new_attr, list): + serialized.extend(new_attr) + 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 'name' not in getattr(orig_attr, '_xml_map', {}): + splitted_tag = new_attr.tag.split("}") + if len(splitted_tag) == 2: # Namespace + new_attr.tag = "}".join([splitted_tag[0], xml_name]) + else: + new_attr.tag = xml_name + serialized.append(new_attr) + else: # That's a basic type + # Integrate namespace if necessary + local_node = _create_xml_node( + xml_name, + xml_prefix, + xml_ns + ) + local_node.text = unicode_str(new_attr) + serialized.append(local_node) + else: # JSON + for k in reversed(keys): + unflattened = {k: new_attr} + new_attr = unflattened + + _new_attr = new_attr + _serialized = serialized + for k in keys: + if k not in _serialized: + _serialized.update(_new_attr) + _new_attr = _new_attr[k] + _serialized = _serialized[k] + except ValueError: + continue + + except (AttributeError, KeyError, TypeError) as err: + msg = "Attribute {} in object {} cannot be serialized.\n{}".format( + attr_name, class_name, str(target_obj)) + raise_with_traceback(SerializationError, msg, err) + else: + return serialized + + def body(self, data, data_type, **kwargs): + """Serialize data intended for a request body. + + :param 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 + """ + + # Just in case this is a dict + internal_data_type = data_type.strip('[]{}') + internal_data_type = self.dependencies.get(internal_data_type, None) + try: + is_xml_model_serialization = kwargs["is_xml"] + except KeyError: + if internal_data_type and issubclass(internal_data_type, Model): + is_xml_model_serialization = kwargs.setdefault("is_xml", internal_data_type.is_xml_model()) + else: + is_xml_model_serialization = False + if internal_data_type and not isinstance(internal_data_type, Enum): + try: + deserializer = Deserializer(self.dependencies) + # Since it's on serialization, it's almost sure that format is not JSON REST + # We're not able to deal with additional properties for now. + deserializer.additional_properties_detection = False + if is_xml_model_serialization: + deserializer.key_extractors = [ + attribute_key_case_insensitive_extractor, + ] + else: + deserializer.key_extractors = [ + rest_key_case_insensitive_extractor, + attribute_key_case_insensitive_extractor, + last_rest_key_case_insensitive_extractor + ] + data = deserializer._deserialize(data_type, data) + except DeserializationError as err: + raise_with_traceback( + SerializationError, "Unable to build a model: "+str(err), err) + + return self._serialize(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 data_type: The type to be serialized from. + :rtype: str + :raises: TypeError if serialization fails. + :raises: ValueError if data is None + """ + try: + output = self.serialize_data(data, data_type, **kwargs) + if data_type == 'bool': + output = json.dumps(output) + + if kwargs.get('skip_quote') is True: + output = str(output) + else: + output = quote(str(output), safe='') + except SerializationError: + raise TypeError("{} must be type {}.".format(name, data_type)) + else: + 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 data_type: The type to be serialized from. + :rtype: str + :raises: TypeError if serialization fails. + :raises: ValueError if data is None + """ + 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] + data = [ + self.serialize_data(d, internal_data_type, **kwargs) if d is not None else "" + for d + in data + ] + if not kwargs.get('skip_quote', False): + data = [ + quote(str(d), safe='') + for d + in data + ] + return str(self.serialize_iter(data, internal_data_type, **kwargs)) + + # Not a list, regular serialization + output = self.serialize_data(data, data_type, **kwargs) + if data_type == 'bool': + output = json.dumps(output) + if kwargs.get('skip_quote') is True: + output = str(output) + else: + output = quote(str(output), safe='') + except SerializationError: + raise TypeError("{} must be type {}.".format(name, data_type)) + else: + 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 data_type: The type to be serialized from. + :rtype: str + :raises: TypeError if serialization fails. + :raises: ValueError if data is None + """ + try: + if data_type in ['[str]']: + data = ["" if d is None else d for d in data] + + 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) + + def serialize_data(self, data, data_type, **kwargs): + """Serialize generic data according to supplied data type. + + :param 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. + """ + if data is None: + raise ValueError("No value for given attribute") + + try: + if data_type in self.basic_types.values(): + return self.serialize_basic(data, data_type, **kwargs) + + elif data_type in self.serialize_type: + return self.serialize_type[data_type](data, **kwargs) + + # If dependencies is empty, try with current data class + # It has to be a subclass of Enum anyway + enum_type = self.dependencies.get(data_type, data.__class__) + if issubclass(enum_type, Enum): + return Serializer.serialize_enum(data, enum_obj=enum_type) + + iter_type = data_type[0] + data_type[-1] + if iter_type in self.serialize_type: + return self.serialize_type[iter_type]( + data, data_type[1:-1], **kwargs) + + except (ValueError, TypeError) as err: + msg = "Unable to serialize value: {!r} as type: {!r}." + raise_with_traceback( + SerializationError, msg.format(data, data_type), err) + else: + return self._serialize(data, **kwargs) + + @classmethod + def _get_custom_serializers(cls, data_type, **kwargs): + custom_serializer = kwargs.get("basic_types_serializers", {}).get(data_type) + if custom_serializer: + return custom_serializer + if kwargs.get("is_xml", False): + return cls._xml_basic_types_serializers.get(data_type) + + @classmethod + def serialize_basic(cls, data, data_type, **kwargs): + """Serialize basic builting data type. + Serializes objects to str, int, float or bool. + + Possible 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 str data_type: Type of object in the iterable. + """ + 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 + + @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. + :rtype: str + """ + try: # If I received an enum, return its value + return data.value + except AttributeError: + pass + + try: + if isinstance(data, unicode): + # Don't change it, JSON and XML ElementTree are totally able + # to serialize correctly u'' strings + return data + except NameError: + return str(data) + else: + return str(data) + + def serialize_iter(self, data, iter_type, div=None, **kwargs): + """Serialize iterable. + + Supported kwargs: + - serialization_ctxt dict : The current entry of _attribute_map, or same format. + 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 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'. + :rtype: list, str + """ + if isinstance(data, str): + raise SerializationError("Refuse str type as a valid iter type.") + + serialization_ctxt = kwargs.get("serialization_ctxt", {}) + is_xml = kwargs.get("is_xml", False) + + serialized = [] + for d in data: + try: + serialized.append(self.serialize_data(d, iter_type, **kwargs)) + except ValueError: + serialized.append(None) + + if div: + serialized = ['' if s is None else str(s) for s in serialized] + serialized = div.join(serialized) + + if 'xml' in serialization_ctxt or is_xml: + # XML serialization is more complicated + xml_desc = serialization_ctxt.get('xml', {}) + xml_name = xml_desc.get('name') + if not xml_name: + xml_name = serialization_ctxt['key'] + + # Create a wrap node if necessary (use the fact that Element and list have "append") + is_wrapped = xml_desc.get("wrapped", False) + node_name = xml_desc.get("itemsName", xml_name) + if is_wrapped: + final_result = _create_xml_node( + xml_name, + xml_desc.get('prefix', None), + xml_desc.get('ns', None) + ) + else: + final_result = [] + # All list elements to "local_node" + for el in serialized: + if isinstance(el, ET.Element): + el_node = el + else: + el_node = _create_xml_node( + node_name, + xml_desc.get('prefix', None), + xml_desc.get('ns', None) + ) + if el is not None: # Otherwise it writes "None" :-p + el_node.text = str(el) + final_result.append(el_node) + return final_result + return serialized + + def serialize_dict(self, attr, dict_type, **kwargs): + """Serialize a dictionary of objects. + + :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 + """ + serialization_ctxt = kwargs.get("serialization_ctxt", {}) + serialized = {} + for key, value in attr.items(): + try: + serialized[self.serialize_unicode(key)] = self.serialize_data( + value, dict_type, **kwargs) + except ValueError: + serialized[self.serialize_unicode(key)] = None + + if 'xml' in serialization_ctxt: + # XML serialization is more complicated + xml_desc = serialization_ctxt['xml'] + xml_name = xml_desc['name'] + + final_result = _create_xml_node( + xml_name, + xml_desc.get('prefix', None), + xml_desc.get('ns', None) + ) + for key, value in serialized.items(): + ET.SubElement(final_result, key).text = value + return final_result + + return serialized + + def serialize_object(self, attr, **kwargs): + """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 + cast to str. + + :param dict attr: Object to be serialized. + :rtype: dict or str + """ + if attr is None: + return None + if isinstance(attr, ET.Element): + return attr + obj_type = type(attr) + if obj_type in self.basic_types: + return self.serialize_basic(attr, self.basic_types[obj_type], **kwargs) + if obj_type is _long_type: + return self.serialize_long(attr) + if obj_type is unicode_str: + return self.serialize_unicode(attr) + if obj_type is datetime.datetime: + return self.serialize_iso(attr) + if obj_type is datetime.date: + return self.serialize_date(attr) + if obj_type is datetime.time: + return self.serialize_time(attr) + if obj_type is datetime.timedelta: + return self.serialize_duration(attr) + if obj_type is decimal.Decimal: + 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): + return self._serialize(attr) + + if obj_type == dict: + serialized = {} + for key, value in attr.items(): + try: + serialized[self.serialize_unicode(key)] = self.serialize_object( + value, **kwargs) + except ValueError: + serialized[self.serialize_unicode(key)] = None + return serialized + + if obj_type == list: + serialized = [] + for obj in attr: + try: + serialized.append(self.serialize_object( + obj, **kwargs)) + except ValueError: + pass + return serialized + return str(attr) + + @staticmethod + def serialize_enum(attr, enum_obj=None): + try: + result = attr.value + except AttributeError: + result = attr + try: + enum_obj(result) + return result + except ValueError: + for enum_value in enum_obj: + 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)) + + @staticmethod + def serialize_bytearray(attr, **kwargs): + """Serialize bytearray into base-64 string. + + :param attr: Object to be serialized. + :rtype: str + """ + return b64encode(attr).decode() + + @staticmethod + def serialize_base64(attr, **kwargs): + """Serialize str into base-64 string. + + :param attr: Object to be serialized. + :rtype: str + """ + encoded = b64encode(attr).decode('ascii') + return encoded.strip('=').replace('+', '-').replace('/', '_') + + @staticmethod + def serialize_decimal(attr, **kwargs): + """Serialize Decimal object to float. + + :param attr: Object to be serialized. + :rtype: float + """ + return float(attr) + + @staticmethod + def serialize_long(attr, **kwargs): + """Serialize long (Py2) or int (Py3). + + :param attr: Object to be serialized. + :rtype: int/long + """ + return _long_type(attr) + + @staticmethod + def serialize_date(attr, **kwargs): + """Serialize Date object into ISO-8601 formatted string. + + :param Date attr: Object to be serialized. + :rtype: str + """ + if isinstance(attr, str): + attr = isodate.parse_date(attr) + t = "{:04}-{:02}-{:02}".format(attr.year, attr.month, attr.day) + return t + + @staticmethod + def serialize_time(attr, **kwargs): + """Serialize Time object into ISO-8601 formatted string. + + :param datetime.time attr: Object to be serialized. + :rtype: str + """ + if isinstance(attr, str): + attr = isodate.parse_time(attr) + t = "{:02}:{:02}:{:02}".format(attr.hour, attr.minute, attr.second) + if attr.microsecond: + t += ".{:02}".format(attr.microsecond) + return t + + @staticmethod + def serialize_duration(attr, **kwargs): + """Serialize TimeDelta object into ISO-8601 formatted string. + + :param TimeDelta attr: Object to be serialized. + :rtype: str + """ + if isinstance(attr, str): + attr = isodate.parse_duration(attr) + return isodate.duration_isoformat(attr) + + @staticmethod + def serialize_rfc(attr, **kwargs): + """Serialize Datetime object into RFC-1123 formatted string. + + :param Datetime attr: Object to be serialized. + :rtype: str + :raises: TypeError if format invalid. + """ + 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.") + + return "{}, {:02} {} {:04} {:02}:{:02}:{:02} GMT".format( + Serializer.days[utc.tm_wday], utc.tm_mday, + Serializer.months[utc.tm_mon], utc.tm_year, + utc.tm_hour, utc.tm_min, utc.tm_sec) + + @staticmethod + def serialize_iso(attr, **kwargs): + """Serialize Datetime object into ISO-8601 formatted string. + + :param Datetime attr: Object to be serialized. + :rtype: str + :raises: SerializationError if format invalid. + """ + if isinstance(attr, str): + attr = isodate.parse_datetime(attr) + try: + if not attr.tzinfo: + _LOGGER.warning( + "Datetime with no tzinfo will be considered UTC.") + utc = attr.utctimetuple() + if utc.tm_year > 9999 or utc.tm_year < 1: + raise OverflowError("Hit max or min date") + + microseconds = str(attr.microsecond).rjust(6,'0').rstrip('0').ljust(3, '0') + if microseconds: + microseconds = '.'+microseconds + date = "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}".format( + utc.tm_year, utc.tm_mon, utc.tm_mday, + utc.tm_hour, utc.tm_min, utc.tm_sec) + return date + microseconds + 'Z' + except (ValueError, OverflowError) as err: + msg = "Unable to serialize datetime object." + raise_with_traceback(SerializationError, msg, err) + except AttributeError as err: + msg = "ISO-8601 object must be valid Datetime object." + raise_with_traceback(TypeError, msg, err) + + @staticmethod + def serialize_unix(attr, **kwargs): + """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 + """ + if isinstance(attr, int): + return attr + try: + 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.") + +def rest_key_extractor(attr, attr_desc, data): + key = attr_desc['key'] + working_data = data + + while '.' in key: + dict_keys = _FLATTEN.split(key) + if len(dict_keys) == 1: + key = _decode_attribute_map_key(dict_keys[0]) + break + working_key = _decode_attribute_map_key(dict_keys[0]) + working_data = working_data.get(working_key, data) + if working_data is None: + # If at any point while following flatten JSON path see None, it means + # that all properties under are None as well + # https://github.com/Azure/msrest-for-python/issues/197 + return None + key = '.'.join(dict_keys[1:]) + + return working_data.get(key) + +def rest_key_case_insensitive_extractor(attr, attr_desc, data): + key = attr_desc['key'] + working_data = data + + while '.' in key: + dict_keys = _FLATTEN.split(key) + if len(dict_keys) == 1: + key = _decode_attribute_map_key(dict_keys[0]) + break + working_key = _decode_attribute_map_key(dict_keys[0]) + working_data = attribute_key_case_insensitive_extractor(working_key, None, working_data) + if working_data is None: + # If at any point while following flatten JSON path see None, it means + # that all properties under are None as well + # https://github.com/Azure/msrest-for-python/issues/197 + return None + key = '.'.join(dict_keys[1:]) + + if working_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. + """ + 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): + """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" + """ + key = attr_desc['key'] + dict_keys = _FLATTEN.split(key) + return attribute_key_case_insensitive_extractor(dict_keys[-1], None, data) + +def attribute_key_extractor(attr, _, data): + return data.get(attr) + +def attribute_key_case_insensitive_extractor(attr, _, data): + found_key = None + lower_attr = attr.lower() + for key in data: + if lower_attr == key.lower(): + found_key = key + break + + return data.get(found_key) + +def _extract_name_from_internal_type(internal_type): + """Given an internal type XML description, extract correct XML name with namespace. + + :param dict internal_type: An model type + :rtype: tuple + :returns: A tuple XML name + namespace dict + """ + internal_type_xml_map = getattr(internal_type, "_xml_map", {}) + xml_name = internal_type_xml_map.get('name', internal_type.__name__) + xml_ns = internal_type_xml_map.get("ns", None) + if xml_ns: + xml_name = "{}{}".format(xml_ns, xml_name) + return xml_name + + +def xml_key_extractor(attr, attr_desc, data): + if isinstance(data, dict): + return None + + # Test if this model is XML ready first + if not isinstance(data, ET.Element): + return None + + xml_desc = attr_desc.get('xml', {}) + xml_name = xml_desc.get('name', attr_desc['key']) + + # Look for a children + is_iter_type = attr_desc['type'].startswith("[") + is_wrapped = xml_desc.get("wrapped", False) + internal_type = attr_desc.get("internalType", None) + internal_type_xml_map = getattr(internal_type, "_xml_map", {}) + + # Integrate namespace if necessary + xml_ns = xml_desc.get('ns', internal_type_xml_map.get("ns", None)) + if xml_ns: + xml_name = "{}{}".format(xml_ns, xml_name) + + # If it's an attribute, that's simple + if xml_desc.get("attr", False): + return data.get(xml_name) + + # If it's x-ms-text, that's simple too + if xml_desc.get("text", False): + return data.text + + # Scenario where I take the local name: + # - Wrapped node + # - Internal type is an enum (considered basic types) + # - Internal type has no XML/Name node + if is_wrapped or (internal_type and (issubclass(internal_type, Enum) or 'name' not in internal_type_xml_map)): + children = data.findall(xml_name) + # If internal type has a local name and it's not a list, I use that name + elif not is_iter_type and internal_type and 'name' in internal_type_xml_map: + xml_name = _extract_name_from_internal_type(internal_type) + children = data.findall(xml_name) + # That's an array + else: + if internal_type: # Complex type, ignore itemsName and use the complex type name + items_name = _extract_name_from_internal_type(internal_type) + else: + items_name = xml_desc.get("itemsName", xml_name) + children = data.findall(items_name) + + if len(children) == 0: + if is_iter_type: + if is_wrapped: + return None # is_wrapped no node, we want None + else: + 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 + )) + 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: + raise DeserializationError("Find several XML '{}' where it was not expected".format(xml_name)) + return children[0] + +class Deserializer(object): + """Response object model deserializer. + + :param dict classes: Class type dictionary for deserializing complex types. + :ivar list key_extractors: Ordered list of extractors to be used by this deserializer. + """ + + 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}]?') + + def __init__(self, classes=None): + self.deserialize_type = { + 'iso-8601': Deserializer.deserialize_iso, + 'rfc-1123': Deserializer.deserialize_rfc, + 'unix-time': Deserializer.deserialize_unix, + 'duration': Deserializer.deserialize_duration, + 'date': Deserializer.deserialize_date, + 'time': Deserializer.deserialize_time, + 'decimal': Deserializer.deserialize_decimal, + 'long': Deserializer.deserialize_long, + 'bytearray': Deserializer.deserialize_bytearray, + 'base64': Deserializer.deserialize_base64, + 'object': self.deserialize_object, + '[]': self.deserialize_iter, + '{}': self.deserialize_dict + } + self.deserialize_expected_types = { + 'duration': (isodate.Duration, datetime.timedelta), + 'iso-8601': (datetime.datetime) + } + self.dependencies = dict(classes) if classes else {} + self.key_extractors = [ + rest_key_extractor, + xml_key_extractor + ] + # Additional properties only works if the "rest_key_extractor" is used to + # extract the keys. Making it to work whatever the key extractor is too much + # complicated, with no real scenario for now. + # So adding a flag to disable additional properties detection. This flag should be + # used if your expect the deserialization to NOT come from a JSON REST syntax. + # Otherwise, result are unexpected + self.additional_properties_detection = True + + def __call__(self, target_obj, response_data, content_type=None): + """Call the deserializer to process a REST response. + + :param str target_obj: Target data type to deserialize to. + :param requests.Response response_data: REST response object. + :param str content_type: Swagger "produces" if available. + :raises: DeserializationError if deserialization fails. + :return: Deserialized object. + """ + data = self._unpack_content(response_data, content_type) + return self._deserialize(target_obj, data) + + def _deserialize(self, target_obj, data): + """Call the deserializer on a model. + + Data needs to be already deserialized as JSON or XML ElementTree + + :param str target_obj: Target data type to deserialize to. + :param object data: Object to deserialize. + :raises: DeserializationError if deserialization fails. + :return: Deserialized 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(): + if attr in constants: + continue + value = getattr(data, attr) + if value is None: + continue + local_type = mapconfig['type'] + internal_data_type = local_type.strip('[]{}') + if internal_data_type not in self.dependencies or isinstance(internal_data_type, Enum): + continue + setattr( + data, + attr, + self._deserialize(local_type, value) + ) + return data + except AttributeError: + return + + response, class_name = self._classify_target(target_obj, data) + + if isinstance(response, basestring): + return self.deserialize_data(data, response) + elif isinstance(response, type) and issubclass(response, Enum): + return self.deserialize_enum(data, response) + + if data is None: + return data + try: + attributes = response._attribute_map + d_attrs = {} + for attr, attr_desc in attributes.items(): + # Check empty string. If it's not empty, someone has a real "additionalProperties"... + if attr == "additional_properties" and attr_desc["key"] == '': + continue + raw_value = None + # Enhance attr_desc with some dynamic data + attr_desc = attr_desc.copy() # Do a copy, do not change the real one + internal_data_type = attr_desc["type"].strip('[]{}') + if internal_data_type in self.dependencies: + attr_desc["internalType"] = self.dependencies[internal_data_type] + + for key_extractor in self.key_extractors: + found_value = key_extractor(attr, attr_desc, data) + if found_value is not None: + if raw_value is not None and raw_value != found_value: + msg = ("Ignoring extracted value '%s' from %s for key '%s'" + " (duplicate extraction, follow extractors order)" ) + _LOGGER.warning( + msg, + found_value, + key_extractor, + attr + ) + continue + raw_value = found_value + + value = self.deserialize_data(raw_value, attr_desc['type']) + d_attrs[attr] = value + except (AttributeError, TypeError, KeyError) as err: + msg = "Unable to deserialize to object: " + class_name + raise_with_traceback(DeserializationError, msg, err) + else: + 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: + return None + if "additional_properties" in attribute_map and attribute_map.get("additional_properties", {}).get("key") != '': + # Check empty string. If it's not empty, someone has a real "additionalProperties" + return None + if isinstance(data, ET.Element): + data = {el.tag: el.text for el in data} + + known_keys = {_decode_attribute_map_key(_FLATTEN.split(desc['key'])[0]) + for desc in attribute_map.values() if desc['key'] != ''} + present_keys = set(data.keys()) + missing_keys = present_keys - known_keys + return {key: data[key] for key in missing_keys} + + def _classify_target(self, target, data): + """Check to see whether the deserialization target object can + be classified into a subclass. + Once classification has been determined, initialize object. + + :param str target: The target object type to deserialize to. + :param str/dict data: The response data to deseralize. + """ + if target is None: + return None, None + + if isinstance(target, basestring): + try: + target = self.dependencies[target] + except KeyError: + return target, target + + try: + target = target._classify(data, self.dependencies) + except AttributeError: + pass # Target is not a Model, no classify + return target, target.__class__.__name__ + + def failsafe_deserialize(self, target_obj, data, content_type=None): + """Ignores any errors encountered in deserialization, + and falls back to not deserializing the object. Recommended + for use in error deserialization, as we want to return the + HttpResponseError to users, and not have them deal with + a deserialization error. + + :param str target_obj: The target object type to deserialize to. + :param str/dict data: The response data to deseralize. + :param str content_type: Swagger "produces" if available. + """ + try: + return self(target_obj, data, content_type=content_type) + except: + _LOGGER.debug( + "Ran into a deserialization error. Ignoring since this is failsafe deserialization", + exc_info=True + ) + return None + + @staticmethod + def _unpack_content(raw_data, content_type=None): + """Extract the correct structure for deserialization. + + If raw_data is a PipelineResponse, try to extract the result of RawDeserializer. + if we can't, raise. Your Pipeline should have a RawDeserializer. + + If not a pipeline response and raw_data is bytes or string, use content-type + to decode it. If no content-type, try JSON. + + 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. + :raises JSONDecodeError: If JSON is requested and parsing is impossible. + :raises UnicodeDecodeError: If bytes is not UTF8 + """ + # Assume this is enough to detect a Pipeline Response without importing it + context = getattr(raw_data, "context", {}) + if context: + if RawDeserializer.CONTEXT_NAME in context: + return context[RawDeserializer.CONTEXT_NAME] + raise ValueError("This pipeline didn't have the RawDeserializer policy; can't deserialize") + + #Assume this is enough to recognize universal_http.ClientResponse without importing it + if hasattr(raw_data, "body"): + return RawDeserializer.deserialize_from_http_generics( + raw_data.text(), + raw_data.headers + ) + + # Assume this enough to recognize requests.Response without importing it. + if hasattr(raw_data, '_content_consumed'): + return RawDeserializer.deserialize_from_http_generics( + raw_data.text, + raw_data.headers + ) + + if isinstance(raw_data, (basestring, bytes)) or hasattr(raw_data, 'read'): + return RawDeserializer.deserialize_from_text(raw_data, content_type) + return raw_data + + 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. + """ + 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')] + 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 + return response_obj + except TypeError as err: + msg = "Unable to deserialize {} into model {}. ".format( + kwargs, response) + raise DeserializationError(msg + str(err)) + else: + try: + for attr, value in attrs.items(): + setattr(response, attr, value) + return response + except Exception as exp: + msg = "Unable to populate response model. " + msg += "Type: {}, Error: {}".format(type(response), exp) + raise DeserializationError(msg) + + def deserialize_data(self, data, data_type): + """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. + """ + if data is None: + return data + + try: + if not data_type: + return data + if data_type in self.basic_types.values(): + return self.deserialize_basic(data, data_type) + if data_type in self.deserialize_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"{}"] + 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) + return data_val + + iter_type = data_type[0] + data_type[-1] + if iter_type in self.deserialize_type: + return self.deserialize_type[iter_type](data, data_type[1:-1]) + + obj_type = self.dependencies[data_type] + if issubclass(obj_type, Enum): + if isinstance(data, ET.Element): + data = data.text + return self.deserialize_enum(data, obj_type) + + except (ValueError, TypeError, AttributeError) as err: + msg = "Unable to deserialize response data." + msg += " Data: {}, {}".format(data, data_type) + raise_with_traceback(DeserializationError, msg, err) + else: + 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. + :rtype: list + """ + if attr is None: + return None + if isinstance(attr, ET.Element): # If I receive an element here, get the children + attr = list(attr) + if not isinstance(attr, (list, set)): + raise DeserializationError("Cannot deserialize as [{}] an object of type {}".format( + iter_type, + type(attr) + )) + return [self.deserialize_data(a, iter_type) for a in attr] + + def deserialize_dict(self, attr, dict_type): + """Deserialize a dictionary. + + :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. + :rtype: dict + """ + if isinstance(attr, list): + return {x['key']: self.deserialize_data(x['value'], dict_type) for x in attr} + + if isinstance(attr, ET.Element): + # Transform value into {"Key": "value"} + 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): + """Deserialize a generic object. + This will be handled as a dictionary. + + :param dict attr: Dictionary to be deserialized. + :rtype: dict + :raises: TypeError if non-builtin datatype encountered. + """ + if attr is None: + return None + if isinstance(attr, ET.Element): + # Do no recurse on XML, just return the tree as-is + return attr + if isinstance(attr, basestring): + return self.deserialize_basic(attr, 'str') + obj_type = type(attr) + if obj_type in self.basic_types: + return self.deserialize_basic(attr, self.basic_types[obj_type]) + if obj_type is _long_type: + return self.deserialize_long(attr) + + if obj_type == dict: + deserialized = {} + for key, value in attr.items(): + try: + deserialized[key] = self.deserialize_object( + value, **kwargs) + except ValueError: + deserialized[key] = None + return deserialized + + if obj_type == list: + deserialized = [] + for obj in attr: + try: + deserialized.append(self.deserialize_object( + obj, **kwargs)) + except ValueError: + pass + return deserialized + + else: + error = "Cannot deserialize generic object with type: " + raise TypeError(error + str(obj_type)) + + def deserialize_basic(self, attr, data_type): + """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 + valid bool values. + + :param str attr: response string to be deserialized. + :param str data_type: deserialization data type. + :rtype: str, int, float or bool + :raises: TypeError if string format is not valid. + """ + # If we're here, data is supposed to be a basic type. + # If it's still an XML node, take the text + if isinstance(attr, ET.Element): + attr = attr.text + if not attr: + 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 + + if data_type == 'bool': + if attr in [True, False, 1, 0]: + return bool(attr) + elif isinstance(attr, basestring): + if attr.lower() in ['true', '1']: + return True + elif 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 + + @staticmethod + def deserialize_unicode(data): + """Preserve unicode objects in Python 2, otherwise return data + as a string. + + :param str data: response string to be deserialized. + :rtype: str or unicode + """ + # We might be here because we have an enum modeled as string, + # and we try to deserialize a partial dict with enum inside + if isinstance(data, Enum): + return data + + # Consider this is real string + try: + if isinstance(data, unicode): + return data + except NameError: + return str(data) + else: + return str(data) + + @staticmethod + def deserialize_enum(data, enum_obj): + """Deserialize string into enum object. + + If the string is not a valid enum value it will be returned as-is + and a warning will be logged. + + :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. + :rtype: Enum + """ + if isinstance(data, enum_obj) or data is None: + return data + if isinstance(data, Enum): + data = data.value + if isinstance(data, int): + # Workaround. We might consider remove it in the future. + # https://github.com/Azure/azure-rest-api-specs/issues/141 + try: + return list(enum_obj.__members__.values())[data] + except IndexError: + error = "{!r} is not a valid index for enum {!r}" + raise DeserializationError(error.format(data, enum_obj)) + try: + return enum_obj(str(data)) + except ValueError: + for enum_value in enum_obj: + if enum_value.value.lower() == str(data).lower(): + return enum_value + # We don't fail anymore for unknown value, we deserialize as a string + _LOGGER.warning("Deserializer is not able to find %s as valid enum in %s", data, enum_obj) + return Deserializer.deserialize_unicode(data) + + @staticmethod + def deserialize_bytearray(attr): + """Deserialize string into bytearray. + + :param str attr: response string to be deserialized. + :rtype: bytearray + :raises: TypeError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + return bytearray(b64decode(attr)) + + @staticmethod + def deserialize_base64(attr): + """Deserialize base64 encoded string into string. + + :param str attr: response string to be deserialized. + :rtype: bytearray + :raises: TypeError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + padding = '=' * (3 - (len(attr) + 3) % 4) + attr = attr + padding + encoded = attr.replace('-', '+').replace('_', '/') + return b64decode(encoded) + + @staticmethod + def deserialize_decimal(attr): + """Deserialize string into Decimal object. + + :param str attr: response string to be deserialized. + :rtype: Decimal + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + return decimal.Decimal(attr) + except decimal.DecimalException as err: + msg = "Invalid decimal {}".format(attr) + raise_with_traceback(DeserializationError, msg, err) + + @staticmethod + def deserialize_long(attr): + """Deserialize string into long (Py2) or int (Py3). + + :param str attr: response string to be deserialized. + :rtype: long or int + :raises: ValueError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + return _long_type(attr) + + @staticmethod + def deserialize_duration(attr): + """Deserialize ISO-8601 formatted string into TimeDelta object. + + :param str attr: response string to be deserialized. + :rtype: TimeDelta + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + duration = isodate.parse_duration(attr) + except(ValueError, OverflowError, AttributeError) as err: + msg = "Cannot deserialize duration object." + raise_with_traceback(DeserializationError, msg, err) + else: + return duration + + @staticmethod + def deserialize_date(attr): + """Deserialize ISO-8601 formatted string into Date object. + + :param str attr: response string to be deserialized. + :rtype: Date + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + if re.search(r"[^\W\d_]", attr, re.I + re.U): + raise DeserializationError("Date must have only digits and -. Received: %s" % attr) + # This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception. + return isodate.parse_date(attr, defaultmonth=None, defaultday=None) + + @staticmethod + def deserialize_time(attr): + """Deserialize ISO-8601 formatted string into time object. + + :param str attr: response string to be deserialized. + :rtype: datetime.time + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + if re.search(r"[^\W\d_]", attr, re.I + re.U): + raise DeserializationError("Date must have only digits and -. Received: %s" % attr) + return isodate.parse_time(attr) + + @staticmethod + def deserialize_rfc(attr): + """Deserialize RFC-1123 formatted string into Datetime object. + + :param str attr: response string to be deserialized. + :rtype: Datetime + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + parsed_date = email.utils.parsedate_tz(attr) + date_obj = datetime.datetime( + *parsed_date[:6], + tzinfo=_FixedOffset(datetime.timedelta(minutes=(parsed_date[9] or 0)/60)) + ) + if not date_obj.tzinfo: + date_obj = date_obj.astimezone(tz=TZ_UTC) + except ValueError as err: + msg = "Cannot deserialize to rfc datetime object." + raise_with_traceback(DeserializationError, msg, err) + else: + return date_obj + + @staticmethod + def deserialize_iso(attr): + """Deserialize ISO-8601 formatted string into Datetime object. + + :param str attr: response string to be deserialized. + :rtype: Datetime + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + attr = attr.upper() + match = Deserializer.valid_date.match(attr) + if not match: + raise ValueError("Invalid datetime string: " + attr) + + check_decimal = attr.split('.') + if len(check_decimal) > 1: + decimal_str = "" + for digit in check_decimal[1]: + if digit.isdigit(): + decimal_str += digit + else: + break + if len(decimal_str) > 6: + attr = attr.replace(decimal_str, decimal_str[0:6]) + + date_obj = isodate.parse_datetime(attr) + test_utc = date_obj.utctimetuple() + if test_utc.tm_year > 9999 or test_utc.tm_year < 1: + raise OverflowError("Hit max or min date") + except(ValueError, OverflowError, AttributeError) as err: + msg = "Cannot deserialize datetime object." + raise_with_traceback(DeserializationError, msg, err) + else: + return date_obj + + @staticmethod + def deserialize_unix(attr): + """Serialize Datetime object into IntTime format. + This is represented as seconds. + + :param int attr: Object to be serialized. + :rtype: Datetime + :raises: DeserializationError if format invalid + """ + if isinstance(attr, ET.Element): + attr = int(attr.text) + try: + date_obj = datetime.datetime.fromtimestamp(attr, TZ_UTC) + except ValueError as err: + msg = "Cannot deserialize to unix datetime object." + raise_with_traceback(DeserializationError, msg, err) + else: + return date_obj diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/aio/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/aio/_configuration.py index 91c050070043..2408e169ca99 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/aio/_configuration.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/aio/_configuration.py @@ -26,9 +26,9 @@ class KeyVaultManagementClientConfiguration(Configuration): 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. + :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. + :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 """ 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 6ede600b362e..8c3f93629489 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 @@ -11,17 +11,15 @@ from typing import Any, Optional, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.mgmt.core import AsyncARMPipelineClient from azure.profiles import KnownProfiles, ProfileDefinition from azure.profiles.multiapiclient import MultiApiClientMixin +from .._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - from azure.core.credentials import TokenCredential from azure.core.credentials_async import AsyncTokenCredential class _SDKClient(object): @@ -42,9 +40,9 @@ class KeyVaultManagementClient(MultiApiClientMixin, _SDKClient): The api-version parameter sets the default API version if the operation group is not described in the profile. - :param credential: Credential needed for the client to connect to Azure. + :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. + :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 api_version: API version to use if no profile is provided, or if missing in profile. :type api_version: str @@ -146,6 +144,7 @@ def keys(self): from ..v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -171,6 +170,7 @@ def managed_hsms(self): from ..v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -193,6 +193,7 @@ def mhsm_private_endpoint_connections(self): from ..v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -215,6 +216,7 @@ def mhsm_private_link_resources(self): from ..v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -249,6 +251,7 @@ def operations(self): from ..v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -280,6 +283,7 @@ def private_endpoint_connections(self): from ..v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -311,6 +315,7 @@ def private_link_resources(self): from ..v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -333,6 +338,7 @@ def secrets(self): from ..v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) @property @@ -367,6 +373,7 @@ def vaults(self): from ..v2022_07_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 return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) async def close(self): 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 d19915ab3650..731fc6d4be82 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 @@ -17,7 +17,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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/v2016_10_01/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_configuration.py index b72d1699755e..e2db86e391d1 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 @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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 "2016-10-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: + def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2016-10-01") # type: str + api_version = kwargs.pop("api_version", "2016-10-01") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,23 +47,24 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) self._configure(**kwargs) def _configure( - self, - **kwargs # type: Any + self, **kwargs # type: Any ): # type: (...) -> 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.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs) + 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) + self.authentication_policy = ARMChallengeAuthenticationPolicy( + self.credential, *self.credential_scopes, **kwargs + ) 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 be3c9e90bbdb..5bdb2c0a0257 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 @@ -9,12 +9,11 @@ from copy import deepcopy from typing import Any, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import HttpRequest, HttpResponse from azure.mgmt.core import ARMPipelineClient from . import models +from .._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration from .operations import Operations, VaultsOperations @@ -22,7 +21,8 @@ # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials import TokenCredential -class KeyVaultManagementClient: + +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. @@ -30,10 +30,10 @@ class KeyVaultManagementClient: :vartype vaults: azure.mgmt.keyvault.v2016_10_01.operations.VaultsOperations :ivar operations: Operations operations :vartype operations: azure.mgmt.keyvault.v2016_10_01.operations.Operations - :param credential: Credential needed for the client to connect to Azure. + :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. + 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 @@ -51,26 +51,19 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = ARMPipelineClient(base_url=base_url, config=self._config, **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 - ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> HttpResponse: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -79,7 +72,7 @@ def _send_request( >>> response = client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_metadata.json b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_metadata.json index 2ebf84dbecff..72d6fbf37e4c 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_metadata.json +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_metadata.json @@ -10,20 +10,20 @@ "azure_arm": true, "has_lro_operations": true, "client_side_validation": false, - "sync_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"ARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}", - "async_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"], \"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"AsyncARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}" + "sync_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"ARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \".._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", + "async_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"AsyncARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \"..._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" }, "global_parameters": { "sync": { "credential": { - "signature": "credential, # type: \"TokenCredential\"", - "description": "Credential needed for the client to connect to Azure.", + "signature": "credential: \"TokenCredential\",", + "description": "Credential needed for the client to connect to Azure. Required.", "docstring_type": "~azure.core.credentials.TokenCredential", "required": true }, "subscription_id": { - "signature": "subscription_id, # type: str", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.", + "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 } @@ -31,13 +31,13 @@ "async": { "credential": { "signature": "credential: \"AsyncTokenCredential\",", - "description": "Credential needed for the client to connect to Azure.", + "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.", + "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 } @@ -54,7 +54,7 @@ "required": false }, "base_url": { - "signature": "base_url=\"https://management.azure.com\", # type: str", + "signature": "base_url: str = \"https://management.azure.com\",", "description": "Service URL", "docstring_type": "str", "required": false diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_patch.py index 74e48ecd07cf..f99e77fef986 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_patch.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_patch.py @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_vendor.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_vendor.py index 138f663c53a4..9aad73fc743e 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_vendor.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/_vendor.py @@ -7,6 +7,7 @@ from azure.core.pipeline.transport import HttpRequest + def _convert_request(request, files=None): data = request.content if not files else None request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) @@ -14,6 +15,7 @@ def _convert_request(request, files=None): request.set_formdata_body(files) return request + def _format_url_section(template, **kwargs): components = template.split("/") while components: @@ -21,7 +23,5 @@ def _format_url_section(template, **kwargs): return template.format(**kwargs) except KeyError as key: formatted_components = template.split("/") - components = [ - c for c in formatted_components if "{}".format(key.args[0]) not in c - ] + components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] template = "/".join(components) 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 c1257f7f4e11..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.1.0" +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 1aa2a0b291a3..c2c64fd1638f 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 @@ -14,7 +14,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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/v2016_10_01/aio/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/_configuration.py index dbb5c2a52da2..ce92d7b4a5c5 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 @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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 "2016-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: + def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2016-10-01") # type: str + api_version = kwargs.pop("api_version", "2016-10-01") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,22 +47,21 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) 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.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) + 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) + self.authentication_policy = AsyncARMChallengeAuthenticationPolicy( + self.credential, *self.credential_scopes, **kwargs + ) 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 1d5472e4496e..2a18a63d630d 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 @@ -9,12 +9,11 @@ from copy import deepcopy from typing import Any, Awaitable, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.mgmt.core import AsyncARMPipelineClient from .. import models +from ..._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration from .operations import Operations, VaultsOperations @@ -22,7 +21,8 @@ # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials_async import AsyncTokenCredential -class KeyVaultManagementClient: + +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. @@ -30,10 +30,10 @@ class KeyVaultManagementClient: :vartype vaults: azure.mgmt.keyvault.v2016_10_01.aio.operations.VaultsOperations :ivar operations: Operations operations :vartype operations: azure.mgmt.keyvault.v2016_10_01.aio.operations.Operations - :param credential: Credential needed for the client to connect to Azure. + :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. + 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 @@ -51,26 +51,19 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **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 - ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -79,7 +72,7 @@ def _send_request( >>> response = await client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/_patch.py index 74e48ecd07cf..f99e77fef986 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/_patch.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/aio/_patch.py @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass 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 28a2756c332a..47205a293051 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 @@ -12,9 +12,10 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'VaultsOperations', - 'Operations', + "VaultsOperations", + "Operations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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 d5fb0c872d89..af987ea74537 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 @@ -7,9 +7,17 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,9 +28,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._operations import build_list_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class Operations: """ .. warning:: @@ -42,36 +52,36 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> AsyncIterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) + :return: An iterator like instance of either Operation or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.Operation] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -79,12 +89,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -101,10 +116,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -114,8 +127,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # type: ignore 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 0ad201a8c586..f7dd32510333 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 @@ -10,6 +10,7 @@ __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. 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 43e9b6d9a3cb..ea5466550538 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,25 @@ from ... import models as _models from ..._vendor import _convert_request -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_initial, build_update_access_policy_request, build_update_request -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class VaultsOperations: """ .. warning:: @@ -45,41 +68,110 @@ def __init__(self, *args, **kwargs) -> None: 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") - - @distributed_trace_async + @overload async def create_or_update( self, resource_group_name: str, vault_name: str, parameters: _models.VaultCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :param parameters: Parameters to create or update the vault. Required. :type parameters: ~azure.mgmt.keyvault.v2016_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 + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + vault_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + vault_name: str, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2016_10_01.models.VaultCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -88,7 +180,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -96,10 +189,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -107,53 +199,122 @@ async def create_or_update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - - @distributed_trace_async + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :param parameters: Parameters to patch the vault. Required. :type parameters: ~azure.mgmt.keyvault.v2016_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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update( + self, + resource_group_name: str, + vault_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2016_10_01.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -162,7 +323,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -170,10 +332,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -181,55 +342,54 @@ async def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -237,10 +397,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -250,45 +409,42 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -296,63 +452,140 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - - @distributed_trace_async + @overload async def update_access_policy( self, resource_group_name: str, vault_name: str, - operation_kind: Union[str, "_models.AccessPolicyUpdateKind"], + 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". + Required. :type operation_kind: str or ~azure.mgmt.keyvault.v2016_10_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. + :param parameters: Access policy to merge into the vault. Required. :type parameters: ~azure.mgmt.keyvault.v2016_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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :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, + *, + 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.v2016_10_01.models.AccessPolicyUpdateKind + :param parameters: Access policy to merge into the vault. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: VaultAccessPolicyParameters or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_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], + **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.v2016_10_01.models.AccessPolicyUpdateKind + :param parameters: Access policy to merge into the vault. Is either a model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2016_10_01.models.VaultAccessPolicyParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: VaultAccessPolicyParameters or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.VaultAccessPolicyParameters + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -362,7 +595,8 @@ async def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -370,10 +604,9 @@ async def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -381,58 +614,58 @@ async def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Vault or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.Vault] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -440,15 +673,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -465,10 +700,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -478,46 +711,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Vault or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.Vault] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -525,14 +755,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -549,10 +782,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -562,43 +793,41 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> AsyncIterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) + :return: An iterator like instance of either DeletedVault or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.DeletedVault] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -606,13 +835,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -629,10 +862,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -642,48 +873,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace_async - async def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -691,50 +917,47 @@ async def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore async def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -742,10 +965,9 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -755,21 +977,15 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace_async - async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -781,99 +997,94 @@ async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace def list( self, + filter: Union[str, _models.Enum5], + api_version: Union[str, _models.Enum6], top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable[_models.ResourceListResult]: + ) -> AsyncIterable["_models.Resource"]: """The List operation gets information about the vaults associated with the subscription. + :param filter: The filter to apply on the operation. "resourceType eq + 'Microsoft.KeyVault/vaults'" Required. + :type filter: str or ~azure.mgmt.keyvault.v2016_10_01.models.Enum5 + :param api_version: Azure Resource Manager Api Version. "2015-11-01" Required. + :type api_version: str or ~azure.mgmt.keyvault.v2016_10_01.models.Enum6 :param top: Maximum number of results to return. Default value is None. :type top: int - :keyword filter: The filter to apply on the operation. Default value is "resourceType eq - 'Microsoft.KeyVault/vaults'". Note that overriding this default value may result in unsupported - behavior. - :paramtype filter: str - :keyword api_version: Azure Resource Manager Api Version. Default value is "2015-11-01". Note - that overriding this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) + :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.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 {}) + _params = kwargs.pop("params", {}) or {} - filter = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, filter=filter, api_version=api_version, top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -881,15 +1092,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -906,10 +1119,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -919,47 +1130,95 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace_async + @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. + :param vault_name: The name of the vault. Required. :type vault_name: ~azure.mgmt.keyvault.v2016_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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def check_name_availability( + self, vault_name: IO, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CheckNameAvailabilityResult or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.CheckNameAvailabilityResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def check_name_availability( + self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO], **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 model type or a IO type. Required. + :type vault_name: ~azure.mgmt.keyvault.v2016_10_01.models.VaultCheckNameAvailabilityParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CheckNameAvailabilityResult or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.CheckNameAvailabilityResult + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -967,22 +1226,20 @@ async def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore 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 1a7469649056..ad061693e4fa 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 @@ -30,54 +30,56 @@ from ._models_py3 import VaultPatchProperties from ._models_py3 import VaultProperties - -from ._key_vault_management_client_enums import ( - AccessPolicyUpdateKind, - CertificatePermissions, - CreateMode, - KeyPermissions, - Reason, - SecretPermissions, - SkuFamily, - SkuName, - StoragePermissions, -) +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 Enum5 +from ._key_vault_management_client_enums import Enum6 +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 from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'AccessPolicyEntry', - 'CheckNameAvailabilityResult', - 'DeletedVault', - 'DeletedVaultListResult', - 'DeletedVaultProperties', - 'LogSpecification', - 'Operation', - 'OperationDisplay', - 'OperationListResult', - 'Permissions', - 'Resource', - 'ResourceListResult', - 'ServiceSpecification', - 'Sku', - 'Vault', - 'VaultAccessPolicyParameters', - 'VaultAccessPolicyProperties', - 'VaultCheckNameAvailabilityParameters', - 'VaultCreateOrUpdateParameters', - 'VaultListResult', - 'VaultPatchParameters', - 'VaultPatchProperties', - 'VaultProperties', - 'AccessPolicyUpdateKind', - 'CertificatePermissions', - 'CreateMode', - 'KeyPermissions', - 'Reason', - 'SecretPermissions', - 'SkuFamily', - 'SkuName', - 'StoragePermissions', + "AccessPolicyEntry", + "CheckNameAvailabilityResult", + "DeletedVault", + "DeletedVaultListResult", + "DeletedVaultProperties", + "LogSpecification", + "Operation", + "OperationDisplay", + "OperationListResult", + "Permissions", + "Resource", + "ResourceListResult", + "ServiceSpecification", + "Sku", + "Vault", + "VaultAccessPolicyParameters", + "VaultAccessPolicyProperties", + "VaultCheckNameAvailabilityParameters", + "VaultCreateOrUpdateParameters", + "VaultListResult", + "VaultPatchParameters", + "VaultPatchProperties", + "VaultProperties", + "AccessPolicyUpdateKind", + "CertificatePermissions", + "CreateMode", + "Enum5", + "Enum6", + "KeyPermissions", + "Reason", + "SecretPermissions", + "SkuFamily", + "SkuName", + "StoragePermissions", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_patch_sdk() diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/_key_vault_management_client_enums.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/_key_vault_management_client_enums.py index cadf1ab4c587..020ac4274427 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/_key_vault_management_client_enums.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/_key_vault_management_client_enums.py @@ -11,18 +11,21 @@ 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_ENUM = "import" + IMPORT = "import" UPDATE = "update" MANAGECONTACTS = "managecontacts" GETISSUERS = "getissuers" @@ -33,14 +36,28 @@ class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): RECOVER = "recover" PURGE = "purge" + class CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The vault's create mode to indicate whether the vault need to be recovered or not. - """ + """The vault's create mode to indicate whether the vault need to be recovered or not.""" RECOVER = "recover" DEFAULT = "default" + +class Enum5(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Enum5.""" + + RESOURCE_TYPE_EQ_MICROSOFT_KEY_VAULT_VAULTS_ = "resourceType eq 'Microsoft.KeyVault/vaults'" + + +class Enum6(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Enum6.""" + + TWO_THOUSAND_FIFTEEN11_01 = "2015-11-01" + + class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """KeyPermissions.""" ENCRYPT = "encrypt" DECRYPT = "decrypt" @@ -52,13 +69,14 @@ class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): LIST = "list" CREATE = "create" UPDATE = "update" - IMPORT_ENUM = "import" + IMPORT = "import" DELETE = "delete" BACKUP = "backup" RESTORE = "restore" RECOVER = "recover" PURGE = "purge" + 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. @@ -67,7 +85,9 @@ class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta): ACCOUNT_NAME_INVALID = "AccountNameInvalid" ALREADY_EXISTS = "AlreadyExists" + class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """SecretPermissions.""" GET = "get" LIST = "list" @@ -78,20 +98,22 @@ class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): RECOVER = "recover" PURGE = "purge" + class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU family name - """ + """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. - """ + """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" 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 24adadc6a20c..fe3d9122034a 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,4 +1,5 @@ # 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. @@ -8,42 +9,42 @@ from typing import Dict, List, Optional, TYPE_CHECKING, Union -import msrest.serialization +from ... import _serialization if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - import __init__ as _models + from .. import models as _models -class AccessPolicyEntry(msrest.serialization.Model): +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 Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and certificates. + :ivar permissions: Permissions the identity has for keys, secrets and certificates. Required. :vartype permissions: ~azure.mgmt.keyvault.v2016_10_01.models.Permissions """ _validation = { - 'tenant_id': {'required': True}, - 'object_id': {'required': True}, - 'permissions': {'required': True}, + "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'}, + "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__( @@ -56,27 +57,27 @@ def __init__( **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and - certificates. + :keyword permissions: Permissions the identity has for keys, secrets and certificates. + Required. :paramtype permissions: ~azure.mgmt.keyvault.v2016_10_01.models.Permissions """ - super(AccessPolicyEntry, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.object_id = object_id self.application_id = application_id self.permissions = permissions -class CheckNameAvailabilityResult(msrest.serialization.Model): +class CheckNameAvailabilityResult(_serialization.Model): """The CheckNameAvailability operation response. Variables are only populated by the server, and will be ignored when sending a request. @@ -86,37 +87,33 @@ class CheckNameAvailabilityResult(msrest.serialization.Model): 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", "AlreadyExists". + returned if NameAvailable is false. Known values are: "AccountNameInvalid" and "AlreadyExists". :vartype reason: str or ~azure.mgmt.keyvault.v2016_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}, + "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'}, + "name_available": {"key": "nameAvailable", "type": "bool"}, + "reason": {"key": "reason", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(CheckNameAvailabilityResult, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.name_available = None self.reason = None self.message = None -class DeletedVault(msrest.serialization.Model): +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. @@ -132,36 +129,31 @@ class DeletedVault(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "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'}, + "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 - ): + def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs): """ :keyword properties: Properties of the vault. :paramtype properties: ~azure.mgmt.keyvault.v2016_10_01.models.DeletedVaultProperties """ - super(DeletedVault, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None self.properties = properties -class DeletedVaultListResult(msrest.serialization.Model): +class DeletedVaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of deleted vaults. @@ -171,16 +163,12 @@ class DeletedVaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DeletedVault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.DeletedVault"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of deleted vaults. @@ -188,12 +176,12 @@ def __init__( :keyword next_link: The URL to get the next set of deleted vaults. :paramtype next_link: str """ - super(DeletedVaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class DeletedVaultProperties(msrest.serialization.Model): +class DeletedVaultProperties(_serialization.Model): """Properties of the deleted vault. Variables are only populated by the server, and will be ignored when sending a request. @@ -206,33 +194,29 @@ class DeletedVaultProperties(msrest.serialization.Model): :vartype deletion_date: ~datetime.datetime :ivar scheduled_purge_date: The scheduled purged date. :vartype scheduled_purge_date: ~datetime.datetime - :ivar tags: A set of tags. Tags of the original vault. + :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}, + "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}'}, + "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 - ): - """ - """ - super(DeletedVaultProperties, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.vault_id = None self.location = None self.deletion_date = None @@ -240,7 +224,7 @@ def __init__( self.tags = None -class LogSpecification(msrest.serialization.Model): +class LogSpecification(_serialization.Model): """Log specification of operation. :ivar name: Name of log specification. @@ -252,9 +236,9 @@ class LogSpecification(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'blob_duration': {'key': 'blobDuration', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "blob_duration": {"key": "blobDuration", "type": "str"}, } def __init__( @@ -273,13 +257,13 @@ def __init__( :keyword blob_duration: Blob duration of specification. :paramtype blob_duration: str """ - super(LogSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.blob_duration = blob_duration -class Operation(msrest.serialization.Model): +class Operation(_serialization.Model): """Key Vault REST API operation definition. :ivar name: Operation name: {provider}/{resource}/{operation}. @@ -293,10 +277,10 @@ class Operation(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display': {'key': 'display', 'type': 'OperationDisplay'}, - 'origin': {'key': 'origin', 'type': 'str'}, - 'service_specification': {'key': 'properties.serviceSpecification', 'type': 'ServiceSpecification'}, + "name": {"key": "name", "type": "str"}, + "display": {"key": "display", "type": "OperationDisplay"}, + "origin": {"key": "origin", "type": "str"}, + "service_specification": {"key": "properties.serviceSpecification", "type": "ServiceSpecification"}, } def __init__( @@ -318,14 +302,14 @@ def __init__( :keyword service_specification: One property of operation, include metric specifications. :paramtype service_specification: ~azure.mgmt.keyvault.v2016_10_01.models.ServiceSpecification """ - super(Operation, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display = display self.origin = origin self.service_specification = service_specification -class OperationDisplay(msrest.serialization.Model): +class OperationDisplay(_serialization.Model): """Display metadata associated with the operation. :ivar provider: Service provider: Microsoft Key Vault. @@ -339,10 +323,10 @@ class OperationDisplay(msrest.serialization.Model): """ _attribute_map = { - 'provider': {'key': 'provider', 'type': 'str'}, - 'resource': {'key': 'resource', 'type': 'str'}, - 'operation': {'key': 'operation', 'type': 'str'}, - 'description': {'key': 'description', 'type': 'str'}, + "provider": {"key": "provider", "type": "str"}, + "resource": {"key": "resource", "type": "str"}, + "operation": {"key": "operation", "type": "str"}, + "description": {"key": "description", "type": "str"}, } def __init__( @@ -364,14 +348,14 @@ def __init__( :keyword description: Description of operation. :paramtype description: str """ - super(OperationDisplay, self).__init__(**kwargs) + super().__init__(**kwargs) self.provider = provider self.resource = resource self.operation = operation self.description = description -class OperationListResult(msrest.serialization.Model): +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. @@ -381,29 +365,23 @@ class OperationListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Operation]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs): """ :keyword value: List of Storage operations supported by the Storage resource provider. :paramtype value: list[~azure.mgmt.keyvault.v2016_10_01.models.Operation] :keyword next_link: The URL to get the next set of operations. :paramtype next_link: str """ - super(OperationListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class Permissions(msrest.serialization.Model): +class Permissions(_serialization.Model): """Permissions the identity has for keys, secrets, certificates and storage. :ivar keys: Permissions to keys. @@ -418,10 +396,10 @@ class Permissions(msrest.serialization.Model): """ _attribute_map = { - 'keys': {'key': 'keys', 'type': '[str]'}, - 'secrets': {'key': 'secrets', 'type': '[str]'}, - 'certificates': {'key': 'certificates', 'type': '[str]'}, - 'storage': {'key': 'storage', 'type': '[str]'}, + "keys": {"key": "keys", "type": "[str]"}, + "secrets": {"key": "secrets", "type": "[str]"}, + "certificates": {"key": "certificates", "type": "[str]"}, + "storage": {"key": "storage", "type": "[str]"}, } def __init__( @@ -444,14 +422,14 @@ def __init__( :keyword storage: Permissions to storage accounts. :paramtype storage: list[str or ~azure.mgmt.keyvault.v2016_10_01.models.StoragePermissions] """ - super(Permissions, self).__init__(**kwargs) + super().__init__(**kwargs) self.keys = keys self.secrets = secrets self.certificates = certificates self.storage = storage -class Resource(msrest.serialization.Model): +class Resource(_serialization.Model): """Key Vault resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -464,42 +442,36 @@ class Resource(msrest.serialization.Model): :vartype name: str :ivar type: The resource type of the key vault. :vartype type: str - :ivar location: Required. The supported Azure location where the key vault should be created. + :ivar location: The supported Azure location where the key vault should be created. Required. :vartype location: str - :ivar tags: A set of tags. The tags that will be assigned to the key vault. + :ivar tags: The tags that will be assigned to the key vault. :vartype tags: dict[str, str] """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'location': {'required': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "location": {"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}'}, + "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, - *, - location: str, - tags: Optional[Dict[str, str]] = None, - **kwargs - ): + def __init__(self, *, location: str, tags: Optional[Dict[str, str]] = None, **kwargs): """ - :keyword location: Required. The supported Azure location where the key vault should be - created. + :keyword location: The supported Azure location where the key vault should be created. + Required. :paramtype location: str - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :keyword tags: The tags that will be assigned to the key vault. :paramtype tags: dict[str, str] """ - super(Resource, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -507,7 +479,7 @@ def __init__( self.tags = tags -class ResourceListResult(msrest.serialization.Model): +class ResourceListResult(_serialization.Model): """List of vault resources. :ivar value: The list of vault resources. @@ -517,29 +489,23 @@ class ResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Resource]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Resource"]] = None, next_link: Optional[str] = None, **kwargs): """ :keyword value: The list of vault resources. :paramtype value: list[~azure.mgmt.keyvault.v2016_10_01.models.Resource] :keyword next_link: The URL to get the next set of vault resources. :paramtype next_link: str """ - super(ResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class ServiceSpecification(msrest.serialization.Model): +class ServiceSpecification(_serialization.Model): """One property of operation, include log specifications. :ivar log_specifications: Log specifications of operation. @@ -547,60 +513,49 @@ class ServiceSpecification(msrest.serialization.Model): """ _attribute_map = { - 'log_specifications': {'key': 'logSpecifications', 'type': '[LogSpecification]'}, + "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, } - def __init__( - self, - *, - log_specifications: Optional[List["_models.LogSpecification"]] = None, - **kwargs - ): + def __init__(self, *, log_specifications: Optional[List["_models.LogSpecification"]] = None, **kwargs): """ :keyword log_specifications: Log specifications of operation. :paramtype log_specifications: list[~azure.mgmt.keyvault.v2016_10_01.models.LogSpecification] """ - super(ServiceSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.log_specifications = log_specifications -class Sku(msrest.serialization.Model): +class Sku(_serialization.Model): """SKU details. All required parameters must be populated in order to send to Azure. - :ivar family: Required. SKU family name. Known values are: "A". + :ivar family: SKU family name. Required. "A" :vartype family: str or ~azure.mgmt.keyvault.v2016_10_01.models.SkuFamily - :ivar name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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.v2016_10_01.models.SkuName """ _validation = { - 'family': {'required': True}, - 'name': {'required': True}, + "family": {"required": True}, + "name": {"required": True}, } _attribute_map = { - 'family': {'key': 'family', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, + "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 - ): + def __init__(self, *, family: Union[str, "_models.SkuFamily"], name: Union[str, "_models.SkuName"], **kwargs): """ - :keyword family: Required. SKU family name. Known values are: "A". + :keyword family: SKU family name. Required. "A" :paramtype family: str or ~azure.mgmt.keyvault.v2016_10_01.models.SkuFamily - :keyword name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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.v2016_10_01.models.SkuName """ - super(Sku, self).__init__(**kwargs) + super().__init__(**kwargs) self.family = family self.name = name @@ -618,53 +573,48 @@ class Vault(Resource): :vartype name: str :ivar type: The resource type of the key vault. :vartype type: str - :ivar location: Required. The supported Azure location where the key vault should be created. + :ivar location: The supported Azure location where the key vault should be created. Required. :vartype location: str - :ivar tags: A set of tags. The tags that will be assigned to the key vault. + :ivar tags: The tags that will be assigned to the key vault. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the vault. + :ivar properties: Properties of the vault. Required. :vartype properties: ~azure.mgmt.keyvault.v2016_10_01.models.VaultProperties """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'location': {'required': True}, - 'properties': {'required': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "location": {"required": 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'}, + "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, - *, - location: str, - properties: "_models.VaultProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs + self, *, location: str, properties: "_models.VaultProperties", tags: Optional[Dict[str, str]] = None, **kwargs ): """ - :keyword location: Required. The supported Azure location where the key vault should be - created. + :keyword location: The supported Azure location where the key vault should be created. + Required. :paramtype location: str - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :keyword tags: The tags that will be assigned to the key vault. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2016_10_01.models.VaultProperties """ - super(Vault, self).__init__(location=location, tags=tags, **kwargs) + super().__init__(location=location, tags=tags, **kwargs) self.properties = properties -class VaultAccessPolicyParameters(msrest.serialization.Model): +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. @@ -679,37 +629,32 @@ class VaultAccessPolicyParameters(msrest.serialization.Model): :vartype type: str :ivar location: The resource type of the access policy. :vartype location: str - :ivar properties: Required. Properties of the access policy. + :ivar properties: Properties of the access policy. Required. :vartype properties: ~azure.mgmt.keyvault.v2016_10_01.models.VaultAccessPolicyProperties """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'location': {'readonly': True}, - 'properties': {'required': True}, + "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'}, + "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 - ): + def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs): """ - :keyword properties: Required. Properties of the access policy. + :keyword properties: Properties of the access policy. Required. :paramtype properties: ~azure.mgmt.keyvault.v2016_10_01.models.VaultAccessPolicyProperties """ - super(VaultAccessPolicyParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -717,127 +662,112 @@ def __init__( self.properties = properties -class VaultAccessPolicyProperties(msrest.serialization.Model): +class VaultAccessPolicyProperties(_serialization.Model): """Properties of the vault access policy. All required parameters must be populated in order to send to Azure. - :ivar access_policies: Required. 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. + :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.v2016_10_01.models.AccessPolicyEntry] """ _validation = { - 'access_policies': {'required': True}, + "access_policies": {"required": True}, } _attribute_map = { - 'access_policies': {'key': 'accessPolicies', 'type': '[AccessPolicyEntry]'}, + "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, } - def __init__( - self, - *, - access_policies: List["_models.AccessPolicyEntry"], - **kwargs - ): + def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwargs): """ - :keyword access_policies: Required. 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. + :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.v2016_10_01.models.AccessPolicyEntry] """ - super(VaultAccessPolicyProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.access_policies = access_policies -class VaultCheckNameAvailabilityParameters(msrest.serialization.Model): +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 Azure. - :ivar name: Required. The vault name. + :ivar name: The vault name. Required. :vartype name: str - :ivar type: The type of resource, Microsoft.KeyVault/vaults. Has constant value: + :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}, + "name": {"required": True}, + "type": {"required": True, "constant": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, } type = "Microsoft.KeyVault/vaults" - def __init__( - self, - *, - name: str, - **kwargs - ): + def __init__(self, *, name: str, **kwargs): """ - :keyword name: Required. The vault name. + :keyword name: The vault name. Required. :paramtype name: str """ - super(VaultCheckNameAvailabilityParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name -class VaultCreateOrUpdateParameters(msrest.serialization.Model): +class VaultCreateOrUpdateParameters(_serialization.Model): """Parameters for creating or updating a vault. All required parameters must be populated in order to send to Azure. - :ivar location: Required. The supported Azure location where the key vault should be created. + :ivar location: The supported Azure location where the key vault should be created. Required. :vartype location: str - :ivar tags: A set of tags. The tags that will be assigned to the key vault. + :ivar tags: The tags that will be assigned to the key vault. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the vault. + :ivar properties: Properties of the vault. Required. :vartype properties: ~azure.mgmt.keyvault.v2016_10_01.models.VaultProperties """ _validation = { - 'location': {'required': True}, - 'properties': {'required': True}, + "location": {"required": True}, + "properties": {"required": True}, } _attribute_map = { - 'location': {'key': 'location', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'VaultProperties'}, + "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 + self, *, location: str, properties: "_models.VaultProperties", tags: Optional[Dict[str, str]] = None, **kwargs ): """ - :keyword location: Required. The supported Azure location where the key vault should be - created. + :keyword location: The supported Azure location where the key vault should be created. + Required. :paramtype location: str - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :keyword tags: The tags that will be assigned to the key vault. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2016_10_01.models.VaultProperties """ - super(VaultCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.location = location self.tags = tags self.properties = properties -class VaultListResult(msrest.serialization.Model): +class VaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of vaults. @@ -847,40 +777,34 @@ class VaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Vault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Vault"]] = None, next_link: Optional[str] = None, **kwargs): """ :keyword value: The list of vaults. :paramtype value: list[~azure.mgmt.keyvault.v2016_10_01.models.Vault] :keyword next_link: The URL to get the next set of vaults. :paramtype next_link: str """ - super(VaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class VaultPatchParameters(msrest.serialization.Model): +class VaultPatchParameters(_serialization.Model): """Parameters for creating or updating a vault. - :ivar tags: A set of tags. The tags that will be assigned to the key 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.v2016_10_01.models.VaultPatchProperties """ _attribute_map = { - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'VaultPatchProperties'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "VaultPatchProperties"}, } def __init__( @@ -891,17 +815,17 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :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.v2016_10_01.models.VaultPatchProperties """ - super(VaultPatchParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class VaultPatchProperties(msrest.serialization.Model): +class VaultPatchProperties(_serialization.Model): """Properties of the vault. :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating @@ -925,7 +849,7 @@ class VaultPatchProperties(msrest.serialization.Model): enabled for this key vault. The property may not be set to false. :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", "default". + or not. Known values are: "recover" and "default". :vartype create_mode: str or ~azure.mgmt.keyvault.v2016_10_01.models.CreateMode :ivar enable_purge_protection: Property specifying whether protection against purge is enabled for this vault; it is only effective if soft delete is also enabled. Once activated, the @@ -934,15 +858,15 @@ class VaultPatchProperties(msrest.serialization.Model): """ _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'}, + "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"}, } def __init__( @@ -981,14 +905,14 @@ def __init__( is enabled for this key vault. The property may not be set to false. :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", "default". + recovered or not. Known values are: "recover" and "default". :paramtype create_mode: str or ~azure.mgmt.keyvault.v2016_10_01.models.CreateMode :keyword enable_purge_protection: Property specifying whether protection against purge is enabled for this vault; it is only effective if soft delete is also enabled. Once activated, the property may no longer be reset to false. :paramtype enable_purge_protection: bool """ - super(VaultPatchProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies @@ -1000,15 +924,15 @@ def __init__( self.enable_purge_protection = enable_purge_protection -class VaultProperties(msrest.serialization.Model): +class VaultProperties(_serialization.Model): """Properties of the vault. All required parameters must be populated in order to send to Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :ivar sku: SKU details. Required. :vartype sku: ~azure.mgmt.keyvault.v2016_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. When @@ -1032,7 +956,7 @@ class VaultProperties(msrest.serialization.Model): that is, the property does not accept false as its 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", "default". + or not. Known values are: "recover" and "default". :vartype create_mode: str or ~azure.mgmt.keyvault.v2016_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 @@ -1043,21 +967,21 @@ class VaultProperties(msrest.serialization.Model): """ _validation = { - 'tenant_id': {'required': True}, - 'sku': {'required': True}, + "tenant_id": {"required": True}, + "sku": {"required": 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'}, + "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"}, } def __init__( @@ -1076,10 +1000,10 @@ def __init__( **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :keyword sku: SKU details. Required. :paramtype sku: ~azure.mgmt.keyvault.v2016_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. When @@ -1103,7 +1027,7 @@ def __init__( - that is, the property does not accept false as its 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", "default". + recovered or not. Known values are: "recover" and "default". :paramtype create_mode: str or ~azure.mgmt.keyvault.v2016_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 @@ -1112,7 +1036,7 @@ def __init__( functionality is irreversible - that is, the property does not accept false as its value. :paramtype enable_purge_protection: bool """ - super(VaultProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/_patch.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/_patch.py index 0ad201a8c586..f7dd32510333 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/_patch.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2016_10_01/models/_patch.py @@ -10,6 +10,7 @@ __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. 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 28a2756c332a..47205a293051 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 @@ -12,9 +12,10 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'VaultsOperations', - 'Operations', + "VaultsOperations", + "Operations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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 0d358b03182a..9332d8a8d8c0 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 @@ -7,10 +7,16 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +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.pipeline.transport import HttpResponse @@ -20,38 +26,34 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request -T = TypeVar('T') + +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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + 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') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class Operations: """ @@ -72,36 +74,35 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> Iterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Operation or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.Operation] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -109,12 +110,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -131,10 +137,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -144,8 +148,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # type: ignore 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 0ad201a8c586..f7dd32510333 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 @@ -10,6 +10,7 @@ __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. 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 9ef0a56749a9..3ff4f9640748 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,471 +28,370 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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, - *, - json: Optional[_models.VaultCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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, - *, - json: Optional[_models.VaultPatchParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}") # pylint: disable=line-too-long + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - **kwargs - ) + 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: +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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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"], + operation_kind: Union[str, _models.AccessPolicyUpdateKind], subscription_id: str, - *, - json: Optional[_models.VaultAccessPolicyParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + 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 + _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'), + "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + 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 + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_purge_deleted_request_initial( - vault_name: str, - location: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge") # pylint: disable=line-too-long + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - return HttpRequest( - method="POST", - url=_url, - params=_params, - **kwargs - ) + return HttpRequest(method="POST", url=_url, params=_params, **kwargs) def build_list_request( subscription_id: str, *, + filter: Union[str, _models.Enum5], + api_version: Union[str, _models.Enum6], top: Optional[int] = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - filter = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - accept = _headers.pop('Accept', "application/json") + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') + _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') + _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 - ) + _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, - *, - json: Optional[_models.VaultCheckNameAvailabilityParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability") + _url = kwargs.pop( + "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability" + ) path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: """ @@ -507,41 +412,110 @@ def __init__(self, *args, **kwargs): 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") - - @distributed_trace + @overload def create_or_update( self, resource_group_name: str, vault_name: str, parameters: _models.VaultCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :param parameters: Parameters to create or update the vault. Required. :type parameters: ~azure.mgmt.keyvault.v2016_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 + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + resource_group_name: str, + vault_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + vault_name: str, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2016_10_01.models.VaultCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -550,7 +524,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -558,10 +533,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -569,53 +543,122 @@ def create_or_update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - - @distributed_trace + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :param parameters: Parameters to patch the vault. Required. :type parameters: ~azure.mgmt.keyvault.v2016_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 + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update( + self, + resource_group_name: str, + vault_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_10_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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2016_10_01.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -624,7 +667,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -632,10 +676,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -643,55 +686,54 @@ def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -699,10 +741,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -712,45 +753,42 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -758,63 +796,140 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace + @overload def update_access_policy( self, resource_group_name: str, vault_name: str, - operation_kind: Union[str, "_models.AccessPolicyUpdateKind"], + 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :param operation_kind: Name of the operation. Known values are: "add", "replace", and "remove". + Required. :type operation_kind: str or ~azure.mgmt.keyvault.v2016_10_01.models.AccessPolicyUpdateKind - :param parameters: Access policy to merge into the vault. + :param parameters: Access policy to merge into the vault. Required. :type parameters: ~azure.mgmt.keyvault.v2016_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 + :keyword callable cls: A custom type or function that will be passed the direct response + :return: VaultAccessPolicyParameters or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_10_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, + *, + 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.v2016_10_01.models.AccessPolicyUpdateKind + :param parameters: Access policy to merge into the vault. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: VaultAccessPolicyParameters or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_10_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], + **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.v2016_10_01.models.AccessPolicyUpdateKind + :param parameters: Access policy to merge into the vault. Is either a model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2016_10_01.models.VaultAccessPolicyParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -824,7 +939,8 @@ def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -832,10 +948,9 @@ def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -843,57 +958,58 @@ def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Vault or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.Vault] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -901,15 +1017,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -926,10 +1044,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -939,45 +1055,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Vault or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.Vault] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -985,14 +1099,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1009,10 +1126,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1022,43 +1137,40 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> Iterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either DeletedVault or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.DeletedVault] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1066,13 +1178,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1089,10 +1205,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1102,48 +1216,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace - def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1151,50 +1260,47 @@ def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -1202,10 +1308,9 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -1215,21 +1320,15 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace - def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -1241,99 +1340,93 @@ def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace def list( self, + filter: Union[str, _models.Enum5], + api_version: Union[str, _models.Enum6], top: Optional[int] = None, **kwargs: Any - ) -> Iterable[_models.ResourceListResult]: + ) -> Iterable["_models.Resource"]: """The List operation gets information about the vaults associated with the subscription. + :param filter: The filter to apply on the operation. "resourceType eq + 'Microsoft.KeyVault/vaults'" Required. + :type filter: str or ~azure.mgmt.keyvault.v2016_10_01.models.Enum5 + :param api_version: Azure Resource Manager Api Version. "2015-11-01" Required. + :type api_version: str or ~azure.mgmt.keyvault.v2016_10_01.models.Enum6 :param top: Maximum number of results to return. Default value is None. :type top: int - :keyword filter: The filter to apply on the operation. Default value is "resourceType eq - 'Microsoft.KeyVault/vaults'". Note that overriding this default value may result in unsupported - behavior. - :paramtype filter: str - :keyword api_version: Azure Resource Manager Api Version. Default value is "2015-11-01". Note - that overriding this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Resource or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~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 {}) + _params = kwargs.pop("params", {}) or {} - filter = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, filter=filter, api_version=api_version, top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -1341,15 +1434,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1366,10 +1461,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1379,47 +1472,95 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace + @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. + :param vault_name: The name of the vault. Required. + :type vault_name: ~azure.mgmt.keyvault.v2016_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 + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CheckNameAvailabilityResult or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.CheckNameAvailabilityResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def check_name_availability( + self, vault_name: IO, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CheckNameAvailabilityResult or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.CheckNameAvailabilityResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def check_name_availability( + self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO], **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 model type or a IO type. Required. :type vault_name: ~azure.mgmt.keyvault.v2016_10_01.models.VaultCheckNameAvailabilityParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2016-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2016-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1427,22 +1568,20 @@ def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore 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/v2018_02_14/__init__.py index d19915ab3650..731fc6d4be82 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/__init__.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/__init__.py @@ -17,7 +17,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_configuration.py index ec15e42d433d..7001a6aa07a1 100644 --- 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 @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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: + def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2018-02-14") # type: str + api_version = kwargs.pop("api_version", "2018-02-14") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,23 +47,24 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) self._configure(**kwargs) def _configure( - self, - **kwargs # type: Any + self, **kwargs # type: Any ): # type: (...) -> 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.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs) + 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) + 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 index b8b552cac871..26848be3144c 100644 --- 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 @@ -9,20 +9,25 @@ from copy import deepcopy from typing import Any, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import HttpRequest, HttpResponse from azure.mgmt.core import ARMPipelineClient from . import models +from .._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration -from .operations import Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, VaultsOperations +from .operations import ( + Operations, + PrivateEndpointConnectionsOperations, + PrivateLinkResourcesOperations, + VaultsOperations, +) if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials import TokenCredential -class KeyVaultManagementClient: + +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. @@ -36,10 +41,10 @@ class KeyVaultManagementClient: 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. + :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. + 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 @@ -57,32 +62,25 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = ARMPipelineClient(base_url=base_url, config=self._config, **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 - ) + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) self.private_endpoint_connections = PrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> HttpResponse: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -91,7 +89,7 @@ def _send_request( >>> response = client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 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 index 16dfb7c56440..17c0a6e08edc 100644 --- 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 @@ -10,20 +10,20 @@ "azure_arm": true, "has_lro_operations": true, "client_side_validation": false, - "sync_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"ARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}", - "async_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"], \"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"AsyncARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}" + "sync_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"ARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \".._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", + "async_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"AsyncARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \"..._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" }, "global_parameters": { "sync": { "credential": { - "signature": "credential, # type: \"TokenCredential\"", - "description": "Credential needed for the client to connect to Azure.", + "signature": "credential: \"TokenCredential\",", + "description": "Credential needed for the client to connect to Azure. Required.", "docstring_type": "~azure.core.credentials.TokenCredential", "required": true }, "subscription_id": { - "signature": "subscription_id, # type: str", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.", + "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 } @@ -31,13 +31,13 @@ "async": { "credential": { "signature": "credential: \"AsyncTokenCredential\",", - "description": "Credential needed for the client to connect to Azure.", + "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.", + "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 } @@ -54,7 +54,7 @@ "required": false }, "base_url": { - "signature": "base_url=\"https://management.azure.com\", # type: str", + "signature": "base_url: str = \"https://management.azure.com\",", "description": "Service URL", "docstring_type": "str", "required": false 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/v2018_02_14/_patch.py index 74e48ecd07cf..f99e77fef986 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_patch.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_patch.py @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_vendor.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_vendor.py index 138f663c53a4..9aad73fc743e 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_vendor.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/_vendor.py @@ -7,6 +7,7 @@ from azure.core.pipeline.transport import HttpRequest + def _convert_request(request, files=None): data = request.content if not files else None request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) @@ -14,6 +15,7 @@ def _convert_request(request, files=None): request.set_formdata_body(files) return request + def _format_url_section(template, **kwargs): components = template.split("/") while components: @@ -21,7 +23,5 @@ def _format_url_section(template, **kwargs): return template.format(**kwargs) except KeyError as key: formatted_components = template.split("/") - components = [ - c for c in formatted_components if "{}".format(key.args[0]) not in c - ] + components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] template = "/".join(components) 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 index c1257f7f4e11..e5754a47ce68 100644 --- 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 @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "10.1.0" +VERSION = "1.0.0b1" 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 index 1aa2a0b291a3..c2c64fd1638f 100644 --- 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 @@ -14,7 +14,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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 index 6730b38e80d8..33ce5e93c90d 100644 --- 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 @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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: + def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2018-02-14") # type: str + api_version = kwargs.pop("api_version", "2018-02-14") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,22 +47,21 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) 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.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) + 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) + 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 index 899c1f139fce..10e1beb53c22 100644 --- 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 @@ -9,20 +9,25 @@ from copy import deepcopy from typing import Any, Awaitable, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.mgmt.core import AsyncARMPipelineClient from .. import models +from ..._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration -from .operations import Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, VaultsOperations +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: + +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. @@ -36,10 +41,10 @@ class KeyVaultManagementClient: 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. + :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. + 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 @@ -57,32 +62,25 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **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 - ) + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) self.private_endpoint_connections = PrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -91,7 +89,7 @@ def _send_request( >>> response = await client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 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/v2018_02_14/aio/_patch.py index 74e48ecd07cf..f99e77fef986 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/_patch.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/aio/_patch.py @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass 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 index 0bc5219d4dff..d52bf5b29e10 100644 --- 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 @@ -14,11 +14,12 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'VaultsOperations', - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'Operations', + "VaultsOperations", + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "Operations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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 index a66ef1ec9567..18881cb7edd4 100644 --- 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 @@ -7,9 +7,17 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,9 +28,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._operations import build_list_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class Operations: """ .. warning:: @@ -42,36 +52,36 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> AsyncIterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) + :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.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -79,12 +89,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -101,10 +116,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -114,8 +127,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # type: ignore 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index 7c8e80983fb7..05c71ad36bc4 100644 --- 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 @@ -6,9 +6,16 @@ # 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, Callable, Dict, Optional, TypeVar, Union, cast - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, 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.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -20,10 +27,16 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._private_endpoint_connections_operations import build_delete_request_initial, build_get_request, build_put_request -T = TypeVar('T') +from ...operations._private_endpoint_connections_operations import ( + build_delete_request, + build_get_request, + build_put_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateEndpointConnectionsOperations: """ .. warning:: @@ -43,48 +56,45 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def get( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -92,74 +102,148 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - - @distributed_trace_async + @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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: PrivateEndpointConnection or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - _json = self._serialize.body(properties, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "PrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -167,10 +251,9 @@ async def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -178,45 +261,44 @@ async def put( 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')) + 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore async def _delete_initial( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -224,10 +306,9 @@ async def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -237,37 +318,31 @@ async def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace_async async def begin_delete( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -281,55 +356,48 @@ async def begin_delete( result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore 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/v2018_02_14/aio/operations/_private_link_resources_operations.py index a87b2d1c9374..7375ece28cc0 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/v2018_02_14/aio/operations/_private_link_resources_operations.py @@ -8,7 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -19,9 +26,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._private_link_resources_operations import build_list_by_vault_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateLinkResourcesOperations: """ .. warning:: @@ -41,43 +50,41 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def list_by_vault( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateLinkResourceListResult, or the result of cls(response) + :return: PrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] - request = build_list_by_vault_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_vault.metadata['url'], + template_url=self.list_by_vault.metadata["url"], headers=_headers, params=_params, ) @@ -85,22 +92,20 @@ async def list_by_vault( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_vault.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore - + list_by_vault.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore 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/v2018_02_14/aio/operations/_vaults_operations.py index faa6cb65a793..c2c3b5b83701 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/v2018_02_14/aio/operations/_vaults_operations.py @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,25 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._vaults_operations import build_check_name_availability_request, build_create_or_update_request_initial, 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_initial, build_update_access_policy_request, build_update_request -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class VaultsOperations: """ .. warning:: @@ -45,36 +68,45 @@ def __init__(self, *args, **kwargs) -> None: 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") - async def _create_or_update_initial( self, resource_group_name: str, vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **kwargs: Any ) -> _models.Vault: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -82,10 +114,9 @@ async def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -93,35 +124,109 @@ async def _create_or_update_initial( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - - @distributed_trace_async + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + vault_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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] + :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], + **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -132,20 +237,17 @@ async def begin_create_or_update( Retry-After header is present. :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] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -153,74 +255,140 @@ async def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace_async + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update( + self, + resource_group_name: str, + vault_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2018_02_14.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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.Vault + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -229,7 +397,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -237,10 +406,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -248,55 +416,54 @@ async def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -304,10 +471,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -317,45 +483,42 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -363,63 +526,140 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - - @distributed_trace_async + @overload async def update_access_policy( self, resource_group_name: str, vault_name: str, - operation_kind: Union[str, "_models.AccessPolicyUpdateKind"], + 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :return: VaultAccessPolicyParameters or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2018_02_14.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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: VaultAccessPolicyParameters or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2018_02_14.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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -429,7 +669,8 @@ async def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -437,10 +678,9 @@ async def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -448,58 +688,58 @@ async def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -507,15 +747,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -532,10 +774,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -545,46 +785,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -592,14 +829,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -616,10 +856,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -629,43 +867,41 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> AsyncIterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) + :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.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -673,13 +909,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -696,10 +936,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -709,48 +947,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace_async - async def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -758,50 +991,47 @@ async def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore async def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -809,10 +1039,9 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -822,21 +1051,15 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace_async - async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -848,99 +1071,94 @@ async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace def list( self, + filter: Union[str, _models.Enum9], + api_version: Union[str, _models.Enum10], top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable[_models.ResourceListResult]: + ) -> AsyncIterable["_models.Resource"]: """The List operation gets information about the vaults associated with the subscription. + :param filter: The filter to apply on the operation. "resourceType eq + 'Microsoft.KeyVault/vaults'" Required. + :type filter: str or ~azure.mgmt.keyvault.v2018_02_14.models.Enum9 + :param api_version: Azure Resource Manager Api Version. "2015-11-01" Required. + :type api_version: str or ~azure.mgmt.keyvault.v2018_02_14.models.Enum10 :param top: Maximum number of results to return. Default value is None. :type top: int - :keyword filter: The filter to apply on the operation. Default value is "resourceType eq - 'Microsoft.KeyVault/vaults'". Note that overriding this default value may result in unsupported - behavior. - :paramtype filter: str - :keyword api_version: Azure Resource Manager Api Version. Default value is "2015-11-01". Note - that overriding this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) + :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.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~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 {}) + _params = kwargs.pop("params", {}) or {} - filter = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, filter=filter, api_version=api_version, top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -948,15 +1166,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -973,10 +1193,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -986,47 +1204,95 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace_async + @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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def check_name_availability( + self, vault_name: IO, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CheckNameAvailabilityResult or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.CheckNameAvailabilityResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def check_name_availability( + self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO], **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 model type or a IO type. Required. + :type vault_name: ~azure.mgmt.keyvault.v2018_02_14.models.VaultCheckNameAvailabilityParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CheckNameAvailabilityResult or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.CheckNameAvailabilityResult + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1034,22 +1300,20 @@ async def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # 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 index 127f5bac6896..30934a00d24c 100644 --- 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 @@ -40,72 +40,74 @@ from ._models_py3 import VaultProperties from ._models_py3 import VirtualNetworkRule - -from ._key_vault_management_client_enums import ( - AccessPolicyUpdateKind, - CertificatePermissions, - CreateMode, - KeyPermissions, - NetworkRuleAction, - NetworkRuleBypassOptions, - PrivateEndpointConnectionProvisioningState, - PrivateEndpointServiceConnectionStatus, - Reason, - SecretPermissions, - SkuFamily, - SkuName, - StoragePermissions, -) +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 Enum10 +from ._key_vault_management_client_enums import Enum9 +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 * # type: ignore # 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', + "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", + "Enum10", + "Enum9", + "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() \ No newline at end of file +_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 index c32d9677a80b..4c2095bf3b9a 100644 --- 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 @@ -11,18 +11,21 @@ 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_ENUM = "import" + IMPORT = "import" UPDATE = "update" MANAGECONTACTS = "managecontacts" GETISSUERS = "getissuers" @@ -35,14 +38,28 @@ class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): BACKUP = "backup" RESTORE = "restore" + class CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The vault's create mode to indicate whether the vault need to be recovered or not. - """ + """The vault's create mode to indicate whether the vault need to be recovered or not.""" RECOVER = "recover" DEFAULT = "default" + +class Enum10(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Enum10.""" + + TWO_THOUSAND_FIFTEEN11_01 = "2015-11-01" + + +class Enum9(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Enum9.""" + + RESOURCE_TYPE_EQ_MICROSOFT_KEY_VAULT_VAULTS_ = "resourceType eq 'Microsoft.KeyVault/vaults'" + + class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """KeyPermissions.""" ENCRYPT = "encrypt" DECRYPT = "decrypt" @@ -54,13 +71,14 @@ class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): LIST = "list" CREATE = "create" UPDATE = "update" - IMPORT_ENUM = "import" + IMPORT = "import" DELETE = "delete" BACKUP = "backup" RESTORE = "restore" RECOVER = "recover" PURGE = "purge" + 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. @@ -69,6 +87,7 @@ class NetworkRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta): 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'. @@ -77,9 +96,9 @@ class NetworkRuleBypassOptions(str, Enum, metaclass=CaseInsensitiveEnumMeta): AZURE_SERVICES = "AzureServices" NONE = "None" + class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The current provisioning state. - """ + """The current provisioning state.""" SUCCEEDED = "Succeeded" CREATING = "Creating" @@ -88,15 +107,16 @@ class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsens FAILED = "Failed" DISCONNECTED = "Disconnected" + class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The private endpoint connection status. - """ + """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. @@ -105,7 +125,9 @@ class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta): ACCOUNT_NAME_INVALID = "AccountNameInvalid" ALREADY_EXISTS = "AlreadyExists" + class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """SecretPermissions.""" GET = "get" LIST = "list" @@ -116,20 +138,22 @@ class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): RECOVER = "recover" PURGE = "purge" + class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU family name - """ + """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. - """ + """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" 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 index fd20a411d5ac..b828b22a3184 100644 --- 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 @@ -1,4 +1,5 @@ # 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. @@ -8,42 +9,42 @@ from typing import Dict, List, Optional, TYPE_CHECKING, Union -import msrest.serialization +from ... import _serialization if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - import __init__ as _models + from .. import models as _models -class AccessPolicyEntry(msrest.serialization.Model): +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 Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and certificates. + :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}, + "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'}, + "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__( @@ -56,27 +57,27 @@ def __init__( **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and - certificates. + :keyword permissions: Permissions the identity has for keys, secrets and certificates. + Required. :paramtype permissions: ~azure.mgmt.keyvault.v2018_02_14.models.Permissions """ - super(AccessPolicyEntry, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.object_id = object_id self.application_id = application_id self.permissions = permissions -class CheckNameAvailabilityResult(msrest.serialization.Model): +class CheckNameAvailabilityResult(_serialization.Model): """The CheckNameAvailability operation response. Variables are only populated by the server, and will be ignored when sending a request. @@ -86,37 +87,33 @@ class CheckNameAvailabilityResult(msrest.serialization.Model): 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", "AlreadyExists". + 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}, + "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'}, + "name_available": {"key": "nameAvailable", "type": "bool"}, + "reason": {"key": "reason", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(CheckNameAvailabilityResult, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.name_available = None self.reason = None self.message = None -class CloudErrorBody(msrest.serialization.Model): +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. @@ -127,17 +124,11 @@ class CloudErrorBody(msrest.serialization.Model): """ _attribute_map = { - 'code': {'key': 'code', 'type': 'str'}, - 'message': {'key': 'message', 'type': 'str'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - *, - code: Optional[str] = None, - message: Optional[str] = None, - **kwargs - ): + def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs): """ :keyword code: Error code. This is a mnemonic that can be consumed programmatically. :paramtype code: str @@ -145,12 +136,12 @@ def __init__( with service version. :paramtype message: str """ - super(CloudErrorBody, self).__init__(**kwargs) + super().__init__(**kwargs) self.code = code self.message = message -class DeletedVault(msrest.serialization.Model): +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. @@ -166,36 +157,31 @@ class DeletedVault(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "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'}, + "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 - ): + def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs): """ :keyword properties: Properties of the vault. :paramtype properties: ~azure.mgmt.keyvault.v2018_02_14.models.DeletedVaultProperties """ - super(DeletedVault, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None self.properties = properties -class DeletedVaultListResult(msrest.serialization.Model): +class DeletedVaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of deleted vaults. @@ -205,16 +191,12 @@ class DeletedVaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DeletedVault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.DeletedVault"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of deleted vaults. @@ -222,12 +204,12 @@ def __init__( :keyword next_link: The URL to get the next set of deleted vaults. :paramtype next_link: str """ - super(DeletedVaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class DeletedVaultProperties(msrest.serialization.Model): +class DeletedVaultProperties(_serialization.Model): """Properties of the deleted vault. Variables are only populated by the server, and will be ignored when sending a request. @@ -240,33 +222,29 @@ class DeletedVaultProperties(msrest.serialization.Model): :vartype deletion_date: ~datetime.datetime :ivar scheduled_purge_date: The scheduled purged date. :vartype scheduled_purge_date: ~datetime.datetime - :ivar tags: A set of tags. Tags of the original vault. + :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}, + "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}'}, + "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 - ): - """ - """ - super(DeletedVaultProperties, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.vault_id = None self.location = None self.deletion_date = None @@ -274,40 +252,35 @@ def __init__( self.tags = None -class IPRule(msrest.serialization.Model): +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 Azure. - :ivar value: Required. 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). + :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}, + "value": {"required": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, + "value": {"key": "value", "type": "str"}, } - def __init__( - self, - *, - value: str, - **kwargs - ): + def __init__(self, *, value: str, **kwargs): """ - :keyword value: Required. 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). + :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(IPRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class LogSpecification(msrest.serialization.Model): +class LogSpecification(_serialization.Model): """Log specification of operation. :ivar name: Name of log specification. @@ -319,9 +292,9 @@ class LogSpecification(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'blob_duration': {'key': 'blobDuration', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "blob_duration": {"key": "blobDuration", "type": "str"}, } def __init__( @@ -340,22 +313,22 @@ def __init__( :keyword blob_duration: Blob duration of specification. :paramtype blob_duration: str """ - super(LogSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.blob_duration = blob_duration -class NetworkRuleSet(msrest.serialization.Model): +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", + '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", "Deny". + "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] @@ -365,10 +338,10 @@ class NetworkRuleSet(msrest.serialization.Model): """ _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]'}, + "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__( @@ -382,12 +355,12 @@ 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", + '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", "Deny". + 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] @@ -395,14 +368,14 @@ def __init__( :paramtype virtual_network_rules: list[~azure.mgmt.keyvault.v2018_02_14.models.VirtualNetworkRule] """ - super(NetworkRuleSet, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class Operation(_serialization.Model): """Key Vault REST API operation definition. :ivar name: Operation name: {provider}/{resource}/{operation}. @@ -416,10 +389,10 @@ class Operation(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display': {'key': 'display', 'type': 'OperationDisplay'}, - 'origin': {'key': 'origin', 'type': 'str'}, - 'service_specification': {'key': 'properties.serviceSpecification', 'type': 'ServiceSpecification'}, + "name": {"key": "name", "type": "str"}, + "display": {"key": "display", "type": "OperationDisplay"}, + "origin": {"key": "origin", "type": "str"}, + "service_specification": {"key": "properties.serviceSpecification", "type": "ServiceSpecification"}, } def __init__( @@ -441,14 +414,14 @@ def __init__( :keyword service_specification: One property of operation, include metric specifications. :paramtype service_specification: ~azure.mgmt.keyvault.v2018_02_14.models.ServiceSpecification """ - super(Operation, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display = display self.origin = origin self.service_specification = service_specification -class OperationDisplay(msrest.serialization.Model): +class OperationDisplay(_serialization.Model): """Display metadata associated with the operation. :ivar provider: Service provider: Microsoft Key Vault. @@ -462,10 +435,10 @@ class OperationDisplay(msrest.serialization.Model): """ _attribute_map = { - 'provider': {'key': 'provider', 'type': 'str'}, - 'resource': {'key': 'resource', 'type': 'str'}, - 'operation': {'key': 'operation', 'type': 'str'}, - 'description': {'key': 'description', 'type': 'str'}, + "provider": {"key": "provider", "type": "str"}, + "resource": {"key": "resource", "type": "str"}, + "operation": {"key": "operation", "type": "str"}, + "description": {"key": "description", "type": "str"}, } def __init__( @@ -487,14 +460,14 @@ def __init__( :keyword description: Description of operation. :paramtype description: str """ - super(OperationDisplay, self).__init__(**kwargs) + super().__init__(**kwargs) self.provider = provider self.resource = resource self.operation = operation self.description = description -class OperationListResult(msrest.serialization.Model): +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. @@ -504,29 +477,23 @@ class OperationListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Operation]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(OperationListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class Permissions(msrest.serialization.Model): +class Permissions(_serialization.Model): """Permissions the identity has for keys, secrets, certificates and storage. :ivar keys: Permissions to keys. @@ -541,10 +508,10 @@ class Permissions(msrest.serialization.Model): """ _attribute_map = { - 'keys': {'key': 'keys', 'type': '[str]'}, - 'secrets': {'key': 'secrets', 'type': '[str]'}, - 'certificates': {'key': 'certificates', 'type': '[str]'}, - 'storage': {'key': 'storage', 'type': '[str]'}, + "keys": {"key": "keys", "type": "[str]"}, + "secrets": {"key": "secrets", "type": "[str]"}, + "certificates": {"key": "certificates", "type": "[str]"}, + "storage": {"key": "storage", "type": "[str]"}, } def __init__( @@ -567,14 +534,14 @@ def __init__( :keyword storage: Permissions to storage accounts. :paramtype storage: list[str or ~azure.mgmt.keyvault.v2018_02_14.models.StoragePermissions] """ - super(Permissions, self).__init__(**kwargs) + super().__init__(**kwargs) self.keys = keys self.secrets = secrets self.certificates = certificates self.storage = storage -class PrivateEndpoint(msrest.serialization.Model): +class PrivateEndpoint(_serialization.Model): """Private endpoint object properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -584,24 +551,20 @@ class PrivateEndpoint(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, + "id": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(PrivateEndpoint, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None -class Resource(msrest.serialization.Model): +class Resource(_serialization.Model): """Key Vault resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -614,33 +577,29 @@ class Resource(msrest.serialization.Model): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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}, + "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}'}, + "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 - ): - """ - """ - super(Resource, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -661,7 +620,7 @@ class PrivateEndpointConnection(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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 @@ -669,29 +628,32 @@ class PrivateEndpointConnection(Resource): :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", "Disconnected". + 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}, + "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'}, + "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__( @@ -708,13 +670,13 @@ def __init__( :paramtype private_link_service_connection_state: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateLinkServiceConnectionState """ - super(PrivateEndpointConnection, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class PrivateEndpointConnectionItem(_serialization.Model): """Private endpoint connection item. Variables are only populated by the server, and will be ignored when sending a request. @@ -725,19 +687,22 @@ class PrivateEndpointConnectionItem(msrest.serialization.Model): :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", "Disconnected". + 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}, + "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'}, + "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__( @@ -754,7 +719,7 @@ def __init__( :paramtype private_link_service_connection_state: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateLinkServiceConnectionState """ - super(PrivateEndpointConnectionItem, self).__init__(**kwargs) + super().__init__(**kwargs) self.private_endpoint = private_endpoint self.private_link_service_connection_state = private_link_service_connection_state self.provisioning_state = None @@ -773,7 +738,7 @@ class PrivateLinkResource(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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 @@ -784,43 +749,38 @@ class PrivateLinkResource(Resource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'location': {'readonly': True}, - 'tags': {'readonly': True}, - 'group_id': {'readonly': True}, - 'required_members': {'readonly': True}, + "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]'}, + "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 - ): + def __init__(self, *, required_zone_names: Optional[List[str]] = None, **kwargs): """ :keyword required_zone_names: Required DNS zone names of the the private link resource. :paramtype required_zone_names: list[str] """ - super(PrivateLinkResource, self).__init__(**kwargs) + super().__init__(**kwargs) self.group_id = None self.required_members = None self.required_zone_names = required_zone_names -class PrivateLinkResourceListResult(msrest.serialization.Model): +class PrivateLinkResourceListResult(_serialization.Model): """A list of private link resources. :ivar value: Array of private link resources. @@ -828,28 +788,23 @@ class PrivateLinkResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[PrivateLinkResource]'}, + "value": {"key": "value", "type": "[PrivateLinkResource]"}, } - def __init__( - self, - *, - value: Optional[List["_models.PrivateLinkResource"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs): """ :keyword value: Array of private link resources. :paramtype value: list[~azure.mgmt.keyvault.v2018_02_14.models.PrivateLinkResource] """ - super(PrivateLinkResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class PrivateLinkServiceConnectionState(msrest.serialization.Model): +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", "Disconnected". + 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. @@ -860,9 +815,9 @@ class PrivateLinkServiceConnectionState(msrest.serialization.Model): """ _attribute_map = { - 'status': {'key': 'status', 'type': 'str'}, - 'description': {'key': 'description', 'type': 'str'}, - 'action_required': {'key': 'actionRequired', 'type': 'str'}, + "status": {"key": "status", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "action_required": {"key": "actionRequired", "type": "str"}, } def __init__( @@ -875,7 +830,7 @@ 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", "Disconnected". + 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. @@ -884,13 +839,13 @@ def __init__( updates on the consumer. :paramtype action_required: str """ - super(PrivateLinkServiceConnectionState, self).__init__(**kwargs) + super().__init__(**kwargs) self.status = status self.description = description self.action_required = action_required -class ResourceListResult(msrest.serialization.Model): +class ResourceListResult(_serialization.Model): """List of vault resources. :ivar value: The list of vault resources. @@ -900,29 +855,23 @@ class ResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Resource]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Resource"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(ResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class ServiceSpecification(msrest.serialization.Model): +class ServiceSpecification(_serialization.Model): """One property of operation, include log specifications. :ivar log_specifications: Log specifications of operation. @@ -930,65 +879,54 @@ class ServiceSpecification(msrest.serialization.Model): """ _attribute_map = { - 'log_specifications': {'key': 'logSpecifications', 'type': '[LogSpecification]'}, + "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, } - def __init__( - self, - *, - log_specifications: Optional[List["_models.LogSpecification"]] = None, - **kwargs - ): + def __init__(self, *, log_specifications: Optional[List["_models.LogSpecification"]] = None, **kwargs): """ :keyword log_specifications: Log specifications of operation. :paramtype log_specifications: list[~azure.mgmt.keyvault.v2018_02_14.models.LogSpecification] """ - super(ServiceSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.log_specifications = log_specifications -class Sku(msrest.serialization.Model): +class Sku(_serialization.Model): """SKU details. All required parameters must be populated in order to send to Azure. - :ivar family: Required. SKU family name. Known values are: "A". + :ivar family: SKU family name. Required. "A" :vartype family: str or ~azure.mgmt.keyvault.v2018_02_14.models.SkuFamily - :ivar name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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}, + "family": {"required": True}, + "name": {"required": True}, } _attribute_map = { - 'family': {'key': 'family', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, + "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 - ): + def __init__(self, *, family: Union[str, "_models.SkuFamily"], name: Union[str, "_models.SkuName"], **kwargs): """ - :keyword family: Required. SKU family name. Known values are: "A". + :keyword family: SKU family name. Required. "A" :paramtype family: str or ~azure.mgmt.keyvault.v2018_02_14.models.SkuFamily - :keyword name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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(Sku, self).__init__(**kwargs) + super().__init__(**kwargs) self.family = family self.name = name -class Vault(msrest.serialization.Model): +class Vault(_serialization.Model): """Resource information with extended details. Variables are only populated by the server, and will be ignored when sending a request. @@ -1003,26 +941,26 @@ class Vault(msrest.serialization.Model): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :ivar tags: Tags assigned to the key vault resource. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the vault. + :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}, + "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'}, + "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__( @@ -1036,12 +974,12 @@ def __init__( """ :keyword location: Azure location of the key vault resource. :paramtype location: str - :keyword tags: A set of tags. Tags assigned to the key vault resource. + :keyword tags: Tags assigned to the key vault resource. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2018_02_14.models.VaultProperties """ - super(Vault, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -1050,7 +988,7 @@ def __init__( self.properties = properties -class VaultAccessPolicyParameters(msrest.serialization.Model): +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. @@ -1065,37 +1003,32 @@ class VaultAccessPolicyParameters(msrest.serialization.Model): :vartype type: str :ivar location: The resource type of the access policy. :vartype location: str - :ivar properties: Required. Properties of the access policy. + :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}, + "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'}, + "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 - ): + def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs): """ - :keyword properties: Required. Properties of the access policy. + :keyword properties: Properties of the access policy. Required. :paramtype properties: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyProperties """ - super(VaultAccessPolicyParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -1103,127 +1036,112 @@ def __init__( self.properties = properties -class VaultAccessPolicyProperties(msrest.serialization.Model): +class VaultAccessPolicyProperties(_serialization.Model): """Properties of the vault access policy. All required parameters must be populated in order to send to Azure. - :ivar access_policies: Required. 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. + :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}, + "access_policies": {"required": True}, } _attribute_map = { - 'access_policies': {'key': 'accessPolicies', 'type': '[AccessPolicyEntry]'}, + "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, } - def __init__( - self, - *, - access_policies: List["_models.AccessPolicyEntry"], - **kwargs - ): + def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwargs): """ - :keyword access_policies: Required. 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. + :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(VaultAccessPolicyProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.access_policies = access_policies -class VaultCheckNameAvailabilityParameters(msrest.serialization.Model): +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 Azure. - :ivar name: Required. The vault name. + :ivar name: The vault name. Required. :vartype name: str - :ivar type: The type of resource, Microsoft.KeyVault/vaults. Has constant value: + :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}, + "name": {"required": True}, + "type": {"required": True, "constant": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, } type = "Microsoft.KeyVault/vaults" - def __init__( - self, - *, - name: str, - **kwargs - ): + def __init__(self, *, name: str, **kwargs): """ - :keyword name: Required. The vault name. + :keyword name: The vault name. Required. :paramtype name: str """ - super(VaultCheckNameAvailabilityParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name -class VaultCreateOrUpdateParameters(msrest.serialization.Model): +class VaultCreateOrUpdateParameters(_serialization.Model): """Parameters for creating or updating a vault. All required parameters must be populated in order to send to Azure. - :ivar location: Required. The supported Azure location where the key vault should be created. + :ivar location: The supported Azure location where the key vault should be created. Required. :vartype location: str - :ivar tags: A set of tags. The tags that will be assigned to the key vault. + :ivar tags: The tags that will be assigned to the key vault. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the vault. + :ivar properties: Properties of the vault. Required. :vartype properties: ~azure.mgmt.keyvault.v2018_02_14.models.VaultProperties """ _validation = { - 'location': {'required': True}, - 'properties': {'required': True}, + "location": {"required": True}, + "properties": {"required": True}, } _attribute_map = { - 'location': {'key': 'location', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'VaultProperties'}, + "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 + self, *, location: str, properties: "_models.VaultProperties", tags: Optional[Dict[str, str]] = None, **kwargs ): """ - :keyword location: Required. The supported Azure location where the key vault should be - created. + :keyword location: The supported Azure location where the key vault should be created. + Required. :paramtype location: str - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :keyword tags: The tags that will be assigned to the key vault. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2018_02_14.models.VaultProperties """ - super(VaultCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.location = location self.tags = tags self.properties = properties -class VaultListResult(msrest.serialization.Model): +class VaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of vaults. @@ -1233,40 +1151,34 @@ class VaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Vault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Vault"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(VaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class VaultPatchParameters(msrest.serialization.Model): +class VaultPatchParameters(_serialization.Model): """Parameters for creating or updating a vault. - :ivar tags: A set of tags. The tags that will be assigned to the key 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'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "VaultPatchProperties"}, } def __init__( @@ -1277,17 +1189,17 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :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(VaultPatchParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class VaultPatchProperties(msrest.serialization.Model): +class VaultPatchProperties(_serialization.Model): """Properties of the vault. :ivar tenant_id: The Azure Active Directory tenant ID that should be used for authenticating @@ -1311,7 +1223,7 @@ class VaultPatchProperties(msrest.serialization.Model): 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", "default". + 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 @@ -1325,16 +1237,16 @@ class VaultPatchProperties(msrest.serialization.Model): """ _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'}, + "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__( @@ -1374,7 +1286,7 @@ def __init__( 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", "default". + 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 @@ -1386,7 +1298,7 @@ def __init__( specific network locations. :paramtype network_acls: ~azure.mgmt.keyvault.v2018_02_14.models.NetworkRuleSet """ - super(VaultPatchProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies @@ -1399,17 +1311,17 @@ def __init__( self.network_acls = network_acls -class VaultProperties(msrest.serialization.Model): +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 Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :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 @@ -1431,7 +1343,7 @@ class VaultProperties(msrest.serialization.Model): 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", "default". + 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 @@ -1449,24 +1361,27 @@ class VaultProperties(msrest.serialization.Model): """ _validation = { - 'tenant_id': {'required': True}, - 'sku': {'required': True}, - 'private_endpoint_connections': {'readonly': True}, + "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]'}, + "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__( @@ -1486,10 +1401,10 @@ def __init__( **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :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 @@ -1511,7 +1426,7 @@ def __init__( 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", "default". + 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 @@ -1523,7 +1438,7 @@ def __init__( locations. :paramtype network_acls: ~azure.mgmt.keyvault.v2018_02_14.models.NetworkRuleSet """ - super(VaultProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies @@ -1538,34 +1453,31 @@ def __init__( self.private_endpoint_connections = None -class VirtualNetworkRule(msrest.serialization.Model): +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 Azure. - :ivar id: Required. Full resource id of a vnet subnet, such as + :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}, + "id": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - *, - id: str, - **kwargs - ): + def __init__(self, *, id: str, **kwargs): # pylint: disable=redefined-builtin """ - :keyword id: Required. Full resource id of a vnet subnet, such as + :keyword id: Full resource id of a vnet subnet, such as '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. + Required. :paramtype id: str """ - super(VirtualNetworkRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id 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/v2018_02_14/models/_patch.py index 0ad201a8c586..f7dd32510333 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/models/_patch.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2018_02_14/models/_patch.py @@ -10,6 +10,7 @@ __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. 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 index 0bc5219d4dff..d52bf5b29e10 100644 --- 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 @@ -14,11 +14,12 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'VaultsOperations', - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'Operations', + "VaultsOperations", + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "Operations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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 index dc9f920f0a55..fc27258196da 100644 --- 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 @@ -7,10 +7,16 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +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.pipeline.transport import HttpResponse @@ -20,38 +26,34 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request -T = TypeVar('T') + +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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + 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') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class Operations: """ @@ -72,36 +74,35 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> Iterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -109,12 +110,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -131,10 +137,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -144,8 +148,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # type: ignore 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index 2ab2ae1e3a7e..937cd6bb31bd 100644 --- 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 @@ -6,11 +6,16 @@ # 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, Callable, Dict, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, 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.pipeline.transport import HttpResponse from azure.core.polling import LROPoller, NoPolling, PollingMethod @@ -21,136 +26,132 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, 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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_put_request( - subscription_id: str, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, - *, - json: Optional[_models.PrivateEndpointConnection] = None, - content: Any = None, + subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) -def build_delete_request_initial( - subscription_id: str, +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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateEndpointConnectionsOperations: """ @@ -171,48 +172,45 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def get( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -220,74 +218,148 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - - @distributed_trace + @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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: PrivateEndpointConnection or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - _json = self._serialize.body(properties, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "PrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -295,10 +367,9 @@ def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -306,45 +377,44 @@ def put( 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')) + 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore def _delete_initial( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -352,10 +422,9 @@ def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -365,37 +434,31 @@ def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def begin_delete( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -409,55 +472,48 @@ def begin_delete( of cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2018_02_14.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 index 4f1badb0f66d..3f3eb1efd7dc 100644 --- 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 @@ -8,9 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,48 +24,46 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateLinkResourcesOperations: """ @@ -81,43 +84,41 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def list_by_vault( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateLinkResourceListResult, or the result of cls(response) + :return: PrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.PrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] - request = build_list_by_vault_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_vault.metadata['url'], + template_url=self.list_by_vault.metadata["url"], headers=_headers, params=_params, ) @@ -125,22 +126,20 @@ def list_by_vault( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_vault.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore - + list_by_vault.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # 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 index 3104ef892780..c50e148c01cc 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,471 +28,370 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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_initial( - resource_group_name: str, - vault_name: str, - subscription_id: str, - *, - json: Optional[_models.VaultCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + +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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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, - *, - json: Optional[_models.VaultPatchParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}") # pylint: disable=line-too-long + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - **kwargs - ) + 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: +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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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"], + operation_kind: Union[str, _models.AccessPolicyUpdateKind], subscription_id: str, - *, - json: Optional[_models.VaultAccessPolicyParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + 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 + _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'), + "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + 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 + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_purge_deleted_request_initial( - vault_name: str, - location: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge") # pylint: disable=line-too-long + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - return HttpRequest( - method="POST", - url=_url, - params=_params, - **kwargs - ) + return HttpRequest(method="POST", url=_url, params=_params, **kwargs) def build_list_request( subscription_id: str, *, + filter: Union[str, _models.Enum9], + api_version: Union[str, _models.Enum10], top: Optional[int] = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - filter = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - accept = _headers.pop('Accept', "application/json") + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') + _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') + _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 - ) + _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, - *, - json: Optional[_models.VaultCheckNameAvailabilityParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability") + _url = kwargs.pop( + "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability" + ) path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: """ @@ -507,36 +412,45 @@ def __init__(self, *args, **kwargs): 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") - def _create_or_update_initial( self, resource_group_name: str, vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **kwargs: Any ) -> _models.Vault: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -544,10 +458,9 @@ def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -555,35 +468,40 @@ def _create_or_update_initial( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :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 :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -594,20 +512,86 @@ def begin_create_or_update( Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + vault_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], + **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -615,74 +599,140 @@ def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def update( + self, + resource_group_name: str, + vault_name: str, + parameters: Union[_models.VaultPatchParameters, IO], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.Vault + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -691,7 +741,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -699,10 +750,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -710,55 +760,54 @@ def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -766,10 +815,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -779,45 +827,42 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -825,63 +870,140 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - - @distributed_trace + @overload def update_access_policy( self, resource_group_name: str, vault_name: str, - operation_kind: Union[str, "_models.AccessPolicyUpdateKind"], + 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: VaultAccessPolicyParameters or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.VaultAccessPolicyParameters + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -891,7 +1013,8 @@ def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -899,10 +1022,9 @@ def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -910,57 +1032,58 @@ def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -968,15 +1091,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -993,10 +1118,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1006,45 +1129,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -1052,14 +1173,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1076,10 +1200,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1089,43 +1211,40 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> Iterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1133,13 +1252,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1156,10 +1279,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1169,48 +1290,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace - def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1218,50 +1334,47 @@ def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -1269,10 +1382,9 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -1282,21 +1394,15 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace - def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -1308,99 +1414,93 @@ def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace def list( self, + filter: Union[str, _models.Enum9], + api_version: Union[str, _models.Enum10], top: Optional[int] = None, **kwargs: Any - ) -> Iterable[_models.ResourceListResult]: + ) -> Iterable["_models.Resource"]: """The List operation gets information about the vaults associated with the subscription. + :param filter: The filter to apply on the operation. "resourceType eq + 'Microsoft.KeyVault/vaults'" Required. + :type filter: str or ~azure.mgmt.keyvault.v2018_02_14.models.Enum9 + :param api_version: Azure Resource Manager Api Version. "2015-11-01" Required. + :type api_version: str or ~azure.mgmt.keyvault.v2018_02_14.models.Enum10 :param top: Maximum number of results to return. Default value is None. :type top: int - :keyword filter: The filter to apply on the operation. Default value is "resourceType eq - 'Microsoft.KeyVault/vaults'". Note that overriding this default value may result in unsupported - behavior. - :paramtype filter: str - :keyword api_version: Azure Resource Manager Api Version. Default value is "2015-11-01". Note - that overriding this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2018_02_14.models.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 {}) + _params = kwargs.pop("params", {}) or {} - filter = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, filter=filter, api_version=api_version, top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -1408,15 +1508,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1433,10 +1535,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1446,47 +1546,95 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace + @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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], **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 model type or a IO type. Required. :type vault_name: ~azure.mgmt.keyvault.v2018_02_14.models.VaultCheckNameAvailabilityParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2018_02_14.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2018-02-14")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2018-02-14")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1494,22 +1642,20 @@ def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # 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 index d19915ab3650..731fc6d4be82 100644 --- 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 @@ -17,7 +17,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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 index 260a732646d9..6c733c83158b 100644 --- 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 @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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: + def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2019-09-01") # type: str + api_version = kwargs.pop("api_version", "2019-09-01") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,23 +47,24 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) self._configure(**kwargs) def _configure( - self, - **kwargs # type: Any + self, **kwargs # type: Any ): # type: (...) -> 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.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs) + 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) + 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 index 3e44eab5ea4f..549f6fb73a1a 100644 --- 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 @@ -9,20 +9,26 @@ from copy import deepcopy from typing import Any, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import HttpRequest, HttpResponse from azure.mgmt.core import ARMPipelineClient from . import models +from .._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration -from .operations import KeysOperations, Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, VaultsOperations +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: + +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. @@ -38,10 +44,10 @@ class KeyVaultManagementClient: :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. + :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. + 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 @@ -59,35 +65,26 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = ARMPipelineClient(base_url=base_url, config=self._config, **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 - ) + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) self.private_endpoint_connections = PrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - self.keys = KeysOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) + self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize) - - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> HttpResponse: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -96,7 +93,7 @@ def _send_request( >>> response = client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 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 index aa8d61615121..b89f189af9e6 100644 --- 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 @@ -10,20 +10,20 @@ "azure_arm": true, "has_lro_operations": true, "client_side_validation": false, - "sync_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"ARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}", - "async_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"], \"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"AsyncARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}" + "sync_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"ARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \".._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", + "async_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"AsyncARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \"..._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" }, "global_parameters": { "sync": { "credential": { - "signature": "credential, # type: \"TokenCredential\"", - "description": "Credential needed for the client to connect to Azure.", + "signature": "credential: \"TokenCredential\",", + "description": "Credential needed for the client to connect to Azure. Required.", "docstring_type": "~azure.core.credentials.TokenCredential", "required": true }, "subscription_id": { - "signature": "subscription_id, # type: str", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.", + "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 } @@ -31,13 +31,13 @@ "async": { "credential": { "signature": "credential: \"AsyncTokenCredential\",", - "description": "Credential needed for the client to connect to Azure.", + "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.", + "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 } @@ -54,7 +54,7 @@ "required": false }, "base_url": { - "signature": "base_url=\"https://management.azure.com\", # type: str", + "signature": "base_url: str = \"https://management.azure.com\",", "description": "Service URL", "docstring_type": "str", "required": false 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/v2019_09_01/_patch.py index 74e48ecd07cf..f99e77fef986 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_patch.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_patch.py @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_vendor.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_vendor.py index 138f663c53a4..9aad73fc743e 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_vendor.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/_vendor.py @@ -7,6 +7,7 @@ from azure.core.pipeline.transport import HttpRequest + def _convert_request(request, files=None): data = request.content if not files else None request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) @@ -14,6 +15,7 @@ def _convert_request(request, files=None): request.set_formdata_body(files) return request + def _format_url_section(template, **kwargs): components = template.split("/") while components: @@ -21,7 +23,5 @@ def _format_url_section(template, **kwargs): return template.format(**kwargs) except KeyError as key: formatted_components = template.split("/") - components = [ - c for c in formatted_components if "{}".format(key.args[0]) not in c - ] + components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] template = "/".join(components) 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/v2019_09_01/_version.py index c1257f7f4e11..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/v2019_09_01/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "10.1.0" +VERSION = "1.0.0b1" 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 index 1aa2a0b291a3..c2c64fd1638f 100644 --- 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 @@ -14,7 +14,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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 index e7cb5418283c..ed53c257232c 100644 --- 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 @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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: + def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2019-09-01") # type: str + api_version = kwargs.pop("api_version", "2019-09-01") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,22 +47,21 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) 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.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) + 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) + 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 index c2e0bb9b3fd4..e870009143cc 100644 --- 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 @@ -9,20 +9,26 @@ from copy import deepcopy from typing import Any, Awaitable, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.mgmt.core import AsyncARMPipelineClient from .. import models +from ..._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration -from .operations import KeysOperations, Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, VaultsOperations +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: + +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. @@ -38,10 +44,10 @@ class KeyVaultManagementClient: :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. + :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. + 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 @@ -59,35 +65,26 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **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 - ) + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) self.private_endpoint_connections = PrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - self.keys = KeysOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) + self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize) - - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -96,7 +93,7 @@ def _send_request( >>> response = await client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 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/v2019_09_01/aio/_patch.py index 74e48ecd07cf..f99e77fef986 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/_patch.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2019_09_01/aio/_patch.py @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass 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 index a30353f460a6..dbb385b69c88 100644 --- 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 @@ -15,12 +15,13 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'VaultsOperations', - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'Operations', - 'KeysOperations', + "VaultsOperations", + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "Operations", + "KeysOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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 index 215f043b2e94..c6b659fc5e81 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,10 +28,18 @@ from ... import models as _models from ..._vendor import _convert_request -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 -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class KeysOperations: """ .. warning:: @@ -43,14 +59,15 @@ def __init__(self, *args, **kwargs) -> None: 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") - - @distributed_trace_async + @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 @@ -58,42 +75,120 @@ async def create_if_not_exist( subsequent versions, and does not update existing keys. :param resource_group_name: The name of the resource group which contains the specified key - vault. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. + :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. + :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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or a + IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.KeyCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Key or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - _json = self._serialize.body(parameters, 'KeyCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "KeyCreateParameters") request = build_create_if_not_exist_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.create_if_not_exist.metadata['url'], + content=_content, + template_url=self.create_if_not_exist.metadata["url"], headers=_headers, params=_params, ) @@ -101,67 +196,61 @@ async def create_if_not_exist( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_if_not_exist.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + create_if_not_exist.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> _models.Key: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. + :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. + :param key_name: The name of the key to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -169,65 +258,61 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace - def list( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.KeyListResult]: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. + :param vault_name: The name of the vault which contains the keys to be retrieved. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -235,15 +320,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -260,10 +347,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -273,57 +358,53 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore @distributed_trace_async async def get_version( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - key_version: str, - **kwargs: Any + 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. + 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. + :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. + :param key_version: The version of the key to be retrieved. Required. :type key_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_version_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get_version.metadata['url'], + template_url=self.get_version.metadata["url"], headers=_headers, params=_params, ) @@ -331,69 +412,67 @@ async def get_version( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_version.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore - + get_version.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore @distributed_trace def list_versions( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.KeyListResult]: + 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. + 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. + :param key_name: The name of the key versions to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_versions_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_versions.metadata['url'], + template_url=self.list_versions.metadata["url"], headers=_headers, params=_params, ) @@ -401,16 +480,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_versions_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -427,10 +507,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -440,8 +518,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_versions.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore + list_versions.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore 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/v2019_09_01/aio/operations/_operations.py index c32e9eefdd49..853da405e50e 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/v2019_09_01/aio/operations/_operations.py @@ -7,9 +7,17 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,9 +28,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._operations import build_list_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class Operations: """ .. warning:: @@ -42,36 +52,36 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> AsyncIterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) + :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.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -79,12 +89,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -101,10 +116,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -114,8 +127,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # type: ignore 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index 316b56edf0f1..a9507b52216f 100644 --- 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 @@ -6,9 +6,16 @@ # 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, Callable, Dict, Optional, TypeVar, Union, cast - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, 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.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -20,10 +27,16 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._private_endpoint_connections_operations import build_delete_request_initial, build_get_request, build_put_request -T = TypeVar('T') +from ...operations._private_endpoint_connections_operations import ( + build_delete_request, + build_get_request, + build_put_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateEndpointConnectionsOperations: """ .. warning:: @@ -43,48 +56,45 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def get( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -92,10 +102,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -104,64 +113,139 @@ async def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - - @distributed_trace_async + @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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: PrivateEndpointConnection or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - _json = self._serialize.body(properties, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "PrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -169,10 +253,9 @@ async def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -180,45 +263,44 @@ async def put( 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')) + 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore async def _delete_initial( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -226,10 +308,9 @@ async def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -239,37 +320,31 @@ async def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace_async async def begin_delete( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -283,55 +358,48 @@ async def begin_delete( result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 index abfe6cd3dfbb..16df456eaf82 100644 --- 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 @@ -8,7 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -19,9 +26,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._private_link_resources_operations import build_list_by_vault_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateLinkResourcesOperations: """ .. warning:: @@ -41,43 +50,41 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def list_by_vault( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateLinkResourceListResult, or the result of cls(response) + :return: PrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] - request = build_list_by_vault_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_vault.metadata['url'], + template_url=self.list_by_vault.metadata["url"], headers=_headers, params=_params, ) @@ -85,22 +92,20 @@ async def list_by_vault( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_vault.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore - + list_by_vault.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # 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 index 35ea6f58e743..6e2a534849d3 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,25 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._vaults_operations import build_check_name_availability_request, build_create_or_update_request_initial, 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_initial, build_update_access_policy_request, build_update_request -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class VaultsOperations: """ .. warning:: @@ -45,36 +68,45 @@ def __init__(self, *args, **kwargs) -> None: 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") - async def _create_or_update_initial( self, resource_group_name: str, vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **kwargs: Any ) -> _models.Vault: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -82,10 +114,9 @@ async def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -93,35 +124,109 @@ async def _create_or_update_initial( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - - @distributed_trace_async + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], + **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -132,20 +237,17 @@ async def begin_create_or_update( Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -153,74 +255,140 @@ async def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace_async + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update( + self, + resource_group_name: str, + vault_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Vault + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -229,7 +397,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -237,10 +406,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -248,55 +416,54 @@ async def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -304,10 +471,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -317,45 +483,42 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -363,63 +526,140 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - - @distributed_trace_async + @overload async def update_access_policy( self, resource_group_name: str, vault_name: str, - operation_kind: Union[str, "_models.AccessPolicyUpdateKind"], + 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -429,7 +669,8 @@ async def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -437,10 +678,9 @@ async def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -448,58 +688,58 @@ async def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -507,15 +747,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -532,10 +774,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -545,46 +785,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -592,14 +829,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -616,10 +856,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -629,43 +867,41 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> AsyncIterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) + :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.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -673,13 +909,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -696,10 +936,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -709,48 +947,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace_async - async def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -758,50 +991,47 @@ async def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore async def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -809,10 +1039,9 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -822,21 +1051,15 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace_async - async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -848,99 +1071,94 @@ async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace def list( self, + filter: Union[str, _models.Enum10], + api_version: Union[str, _models.Enum11], top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable[_models.ResourceListResult]: + ) -> AsyncIterable["_models.Resource"]: """The List operation gets information about the vaults associated with the subscription. + :param filter: The filter to apply on the operation. "resourceType eq + 'Microsoft.KeyVault/vaults'" Required. + :type filter: str or ~azure.mgmt.keyvault.v2019_09_01.models.Enum10 + :param api_version: Azure Resource Manager Api Version. "2015-11-01" Required. + :type api_version: str or ~azure.mgmt.keyvault.v2019_09_01.models.Enum11 :param top: Maximum number of results to return. Default value is None. :type top: int - :keyword filter: The filter to apply on the operation. Default value is "resourceType eq - 'Microsoft.KeyVault/vaults'". Note that overriding this default value may result in unsupported - behavior. - :paramtype filter: str - :keyword api_version: Azure Resource Manager Api Version. Default value is "2015-11-01". Note - that overriding this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) + :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.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 {}) + _params = kwargs.pop("params", {}) or {} - filter = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, filter=filter, api_version=api_version, top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -948,15 +1166,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -973,10 +1193,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -986,47 +1204,95 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace_async + @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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def check_name_availability( + self, vault_name: IO, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], **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 model type or a IO type. Required. + :type vault_name: ~azure.mgmt.keyvault.v2019_09_01.models.VaultCheckNameAvailabilityParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CheckNameAvailabilityResult or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.CheckNameAvailabilityResult + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1034,22 +1300,20 @@ async def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # 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 index 9b9f5d4fc734..64d18756597e 100644 --- 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 @@ -48,90 +48,92 @@ from ._models_py3 import VaultProperties from ._models_py3 import VirtualNetworkRule - -from ._key_vault_management_client_enums import ( - AccessPolicyUpdateKind, - CertificatePermissions, - CreateMode, - DeletionRecoveryLevel, - JsonWebKeyCurveName, - JsonWebKeyOperation, - JsonWebKeyType, - KeyPermissions, - NetworkRuleAction, - NetworkRuleBypassOptions, - PrivateEndpointConnectionProvisioningState, - PrivateEndpointServiceConnectionStatus, - Reason, - SecretPermissions, - SkuFamily, - SkuName, - StoragePermissions, - VaultProvisioningState, -) +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 Enum10 +from ._key_vault_management_client_enums import Enum11 +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 * # type: ignore # 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', + "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", + "Enum10", + "Enum11", + "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() \ No newline at end of file +_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 index bd3253f802a8..7c15c28d1dd9 100644 --- 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 @@ -11,19 +11,22 @@ 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_ENUM = "import" + IMPORT = "import" UPDATE = "update" MANAGECONTACTS = "managecontacts" GETISSUERS = "getissuers" @@ -36,13 +39,14 @@ class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): BACKUP = "backup" RESTORE = "restore" + class CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The vault's create mode to indicate whether the vault need to be recovered or not. - """ + """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 @@ -54,15 +58,28 @@ class DeletionRecoveryLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta): RECOVERABLE = "Recoverable" RECOVERABLE_PROTECTED_SUBSCRIPTION = "Recoverable+ProtectedSubscription" + +class Enum10(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Enum10.""" + + RESOURCE_TYPE_EQ_MICROSOFT_KEY_VAULT_VAULTS_ = "resourceType eq 'Microsoft.KeyVault/vaults'" + + +class Enum11(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Enum11.""" + + TWO_THOUSAND_FIFTEEN11_01 = "2015-11-01" + + class JsonWebKeyCurveName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The elliptic curve name. For valid values, see JsonWebKeyCurveName. - """ + """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. @@ -74,18 +91,20 @@ class JsonWebKeyOperation(str, Enum, metaclass=CaseInsensitiveEnumMeta): VERIFY = "verify" WRAP_KEY = "wrapKey" UNWRAP_KEY = "unwrapKey" - IMPORT_ENUM = "import" + IMPORT = "import" + class JsonWebKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of the key. For valid values, see JsonWebKeyType. - """ + """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" @@ -98,13 +117,14 @@ class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): LIST = "list" CREATE = "create" UPDATE = "update" - IMPORT_ENUM = "import" + IMPORT = "import" DELETE = "delete" BACKUP = "backup" RESTORE = "restore" RECOVER = "recover" PURGE = "purge" + 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. @@ -113,6 +133,7 @@ class NetworkRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta): 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'. @@ -121,9 +142,9 @@ class NetworkRuleBypassOptions(str, Enum, metaclass=CaseInsensitiveEnumMeta): AZURE_SERVICES = "AzureServices" NONE = "None" + class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The current provisioning state. - """ + """The current provisioning state.""" SUCCEEDED = "Succeeded" CREATING = "Creating" @@ -132,15 +153,16 @@ class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsens FAILED = "Failed" DISCONNECTED = "Disconnected" + class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The private endpoint connection status. - """ + """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. @@ -149,7 +171,9 @@ class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta): ACCOUNT_NAME_INVALID = "AccountNameInvalid" ALREADY_EXISTS = "AlreadyExists" + class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """SecretPermissions.""" ALL = "all" GET = "get" @@ -161,20 +185,22 @@ class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): RECOVER = "recover" PURGE = "purge" + class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU family name - """ + """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. - """ + """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" @@ -192,9 +218,9 @@ class StoragePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): GETSAS = "getsas" DELETESAS = "deletesas" + class VaultProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state of the vault. - """ + """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 index f5dca3befdbb..feb591de811f 100644 --- 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 @@ -1,4 +1,5 @@ # 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. @@ -8,42 +9,42 @@ from typing import Dict, List, Optional, TYPE_CHECKING, Union -import msrest.serialization +from ... import _serialization if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - import __init__ as _models + from .. import models as _models -class AccessPolicyEntry(msrest.serialization.Model): +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 Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and certificates. + :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}, + "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'}, + "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__( @@ -56,27 +57,27 @@ def __init__( **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and - certificates. + :keyword permissions: Permissions the identity has for keys, secrets and certificates. + Required. :paramtype permissions: ~azure.mgmt.keyvault.v2019_09_01.models.Permissions """ - super(AccessPolicyEntry, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.object_id = object_id self.application_id = application_id self.permissions = permissions -class Attributes(msrest.serialization.Model): +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. @@ -84,34 +85,34 @@ class Attributes(msrest.serialization.Model): :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: long + :vartype not_before: int :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: long + :vartype expires: int :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: long + :vartype created: int :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: long + :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", + 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}, + "created": {"readonly": True}, + "updated": {"readonly": True}, + "recovery_level": {"readonly": True}, } _attribute_map = { - 'enabled': {'key': 'enabled', 'type': 'bool'}, - 'not_before': {'key': 'nbf', 'type': 'long'}, - 'expires': {'key': 'exp', 'type': 'long'}, - 'created': {'key': 'created', 'type': 'long'}, - 'updated': {'key': 'updated', 'type': 'long'}, - 'recovery_level': {'key': 'recoveryLevel', 'type': 'str'}, + "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__( @@ -126,11 +127,11 @@ def __init__( :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: long + :paramtype not_before: int :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :paramtype expires: long + :paramtype expires: int """ - super(Attributes, self).__init__(**kwargs) + super().__init__(**kwargs) self.enabled = enabled self.not_before = not_before self.expires = expires @@ -139,7 +140,7 @@ def __init__( self.recovery_level = None -class CheckNameAvailabilityResult(msrest.serialization.Model): +class CheckNameAvailabilityResult(_serialization.Model): """The CheckNameAvailability operation response. Variables are only populated by the server, and will be ignored when sending a request. @@ -149,37 +150,33 @@ class CheckNameAvailabilityResult(msrest.serialization.Model): 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", "AlreadyExists". + 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}, + "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'}, + "name_available": {"key": "nameAvailable", "type": "bool"}, + "reason": {"key": "reason", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(CheckNameAvailabilityResult, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.name_available = None self.reason = None self.message = None -class CloudErrorBody(msrest.serialization.Model): +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. @@ -190,17 +187,11 @@ class CloudErrorBody(msrest.serialization.Model): """ _attribute_map = { - 'code': {'key': 'code', 'type': 'str'}, - 'message': {'key': 'message', 'type': 'str'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - *, - code: Optional[str] = None, - message: Optional[str] = None, - **kwargs - ): + def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs): """ :keyword code: Error code. This is a mnemonic that can be consumed programmatically. :paramtype code: str @@ -208,12 +199,12 @@ def __init__( with service version. :paramtype message: str """ - super(CloudErrorBody, self).__init__(**kwargs) + super().__init__(**kwargs) self.code = code self.message = message -class DeletedVault(msrest.serialization.Model): +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. @@ -229,36 +220,31 @@ class DeletedVault(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "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'}, + "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 - ): + def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs): """ :keyword properties: Properties of the vault. :paramtype properties: ~azure.mgmt.keyvault.v2019_09_01.models.DeletedVaultProperties """ - super(DeletedVault, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None self.properties = properties -class DeletedVaultListResult(msrest.serialization.Model): +class DeletedVaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of deleted vaults. @@ -268,16 +254,12 @@ class DeletedVaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DeletedVault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.DeletedVault"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of deleted vaults. @@ -285,12 +267,12 @@ def __init__( :keyword next_link: The URL to get the next set of deleted vaults. :paramtype next_link: str """ - super(DeletedVaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class DeletedVaultProperties(msrest.serialization.Model): +class DeletedVaultProperties(_serialization.Model): """Properties of the deleted vault. Variables are only populated by the server, and will be ignored when sending a request. @@ -303,37 +285,33 @@ class DeletedVaultProperties(msrest.serialization.Model): :vartype deletion_date: ~datetime.datetime :ivar scheduled_purge_date: The scheduled purged date. :vartype scheduled_purge_date: ~datetime.datetime - :ivar tags: A set of tags. Tags of the original vault. + :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}, + "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'}, + "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 - ): - """ - """ - super(DeletedVaultProperties, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.vault_id = None self.location = None self.deletion_date = None @@ -342,7 +320,7 @@ def __init__( self.purge_protection_enabled = None -class DimensionProperties(msrest.serialization.Model): +class DimensionProperties(_serialization.Model): """Type of operation: get, read, delete, etc. :ivar name: Name of dimension. @@ -355,9 +333,9 @@ class DimensionProperties(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'to_be_exported_for_shoebox': {'key': 'toBeExportedForShoebox', 'type': 'bool'}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "to_be_exported_for_shoebox": {"key": "toBeExportedForShoebox", "type": "bool"}, } def __init__( @@ -377,46 +355,41 @@ def __init__( exported for shoebox. :paramtype to_be_exported_for_shoebox: bool """ - super(DimensionProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.to_be_exported_for_shoebox = to_be_exported_for_shoebox -class IPRule(msrest.serialization.Model): +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 Azure. - :ivar value: Required. 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). + :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}, + "value": {"required": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, + "value": {"key": "value", "type": "str"}, } - def __init__( - self, - *, - value: str, - **kwargs - ): + def __init__(self, *, value: str, **kwargs): """ - :keyword value: Required. 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). + :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(IPRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class Resource(msrest.serialization.Model): +class Resource(_serialization.Model): """Key Vault resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -429,33 +402,29 @@ class Resource(msrest.serialization.Model): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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}, + "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}'}, + "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 - ): - """ - """ - super(Resource, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -463,7 +432,7 @@ def __init__( self.tags = None -class Key(Resource): +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. @@ -476,19 +445,19 @@ class Key(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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", "RSA-HSM". + "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", "P-256K". + 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 @@ -497,28 +466,28 @@ class Key(Resource): """ _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}, + "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'}, + "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__( @@ -535,17 +504,17 @@ def __init__( :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", "RSA-HSM". + "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", "P-256K". + 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(Key, self).__init__(**kwargs) + super().__init__(**kwargs) self.attributes = attributes self.kty = kty self.key_ops = key_ops @@ -563,34 +532,34 @@ class KeyAttributes(Attributes): :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: long + :vartype not_before: int :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: long + :vartype expires: int :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: long + :vartype created: int :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: long + :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", + 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}, + "created": {"readonly": True}, + "updated": {"readonly": True}, + "recovery_level": {"readonly": True}, } _attribute_map = { - 'enabled': {'key': 'enabled', 'type': 'bool'}, - 'not_before': {'key': 'nbf', 'type': 'long'}, - 'expires': {'key': 'exp', 'type': 'long'}, - 'created': {'key': 'created', 'type': 'long'}, - 'updated': {'key': 'updated', 'type': 'long'}, - 'recovery_level': {'key': 'recoveryLevel', 'type': 'str'}, + "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__( @@ -605,52 +574,46 @@ def __init__( :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: long + :paramtype not_before: int :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :paramtype expires: long + :paramtype expires: int """ - super(KeyAttributes, self).__init__(enabled=enabled, not_before=not_before, expires=expires, **kwargs) + super().__init__(enabled=enabled, not_before=not_before, expires=expires, **kwargs) -class KeyCreateParameters(msrest.serialization.Model): +class KeyCreateParameters(_serialization.Model): """The parameters used to create a key. All required parameters must be populated in order to send to Azure. - :ivar tags: A set of tags. The tags that will be assigned to the key. + :ivar tags: The tags that will be assigned to the key. :vartype tags: dict[str, str] - :ivar properties: Required. The properties of the key to be created. + :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}, + "properties": {"required": True}, } _attribute_map = { - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'KeyProperties'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "KeyProperties"}, } - def __init__( - self, - *, - properties: "_models.KeyProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs - ): + def __init__(self, *, properties: "_models.KeyProperties", tags: Optional[Dict[str, str]] = None, **kwargs): """ - :keyword tags: A set of tags. The tags that will be assigned to the key. + :keyword tags: The tags that will be assigned to the key. :paramtype tags: dict[str, str] - :keyword properties: Required. The properties of the key to be created. + :keyword properties: The properties of the key to be created. Required. :paramtype properties: ~azure.mgmt.keyvault.v2019_09_01.models.KeyProperties """ - super(KeyCreateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class KeyListResult(msrest.serialization.Model): +class KeyListResult(_serialization.Model): """The page of keys. :ivar value: The key resources. @@ -660,29 +623,23 @@ class KeyListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Key]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Key"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(KeyListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class KeyProperties(msrest.serialization.Model): +class KeyProperties(_serialization.Model): """The properties of the key. Variables are only populated by the server, and will be ignored when sending a request. @@ -690,14 +647,14 @@ class KeyProperties(msrest.serialization.Model): :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", "RSA-HSM". + "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", "P-256K". + 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 @@ -706,18 +663,18 @@ class KeyProperties(msrest.serialization.Model): """ _validation = { - 'key_uri': {'readonly': True}, - 'key_uri_with_version': {'readonly': True}, + "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'}, + "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__( @@ -734,17 +691,17 @@ def __init__( :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", "RSA-HSM". + "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", "P-256K". + 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(KeyProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.attributes = attributes self.kty = kty self.key_ops = key_ops @@ -754,7 +711,7 @@ def __init__( self.key_uri_with_version = None -class LogSpecification(msrest.serialization.Model): +class LogSpecification(_serialization.Model): """Log specification of operation. :ivar name: Name of log specification. @@ -766,9 +723,9 @@ class LogSpecification(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'blob_duration': {'key': 'blobDuration', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "blob_duration": {"key": "blobDuration", "type": "str"}, } def __init__( @@ -787,13 +744,13 @@ def __init__( :keyword blob_duration: Blob duration of specification. :paramtype blob_duration: str """ - super(LogSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.blob_duration = blob_duration -class MetricSpecification(msrest.serialization.Model): +class MetricSpecification(_serialization.Model): # pylint: disable=too-many-instance-attributes """Metric specification of operation. :ivar name: Name of metric specification. @@ -822,17 +779,17 @@ class MetricSpecification(msrest.serialization.Model): """ _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'}, + "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__( @@ -876,7 +833,7 @@ def __init__( :keyword internal_metric_name: The internal metric name. :paramtype internal_metric_name: str """ - super(MetricSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.display_description = display_description @@ -890,16 +847,16 @@ def __init__( self.internal_metric_name = internal_metric_name -class NetworkRuleSet(msrest.serialization.Model): +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", + '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", "Deny". + "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] @@ -909,10 +866,10 @@ class NetworkRuleSet(msrest.serialization.Model): """ _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]'}, + "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__( @@ -926,12 +883,12 @@ 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", + '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", "Deny". + 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] @@ -939,14 +896,14 @@ def __init__( :paramtype virtual_network_rules: list[~azure.mgmt.keyvault.v2019_09_01.models.VirtualNetworkRule] """ - super(NetworkRuleSet, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class Operation(_serialization.Model): """Key Vault REST API operation definition. :ivar name: Operation name: {provider}/{resource}/{operation}. @@ -962,11 +919,11 @@ class Operation(msrest.serialization.Model): """ _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'}, + "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__( @@ -991,7 +948,7 @@ def __init__( :keyword service_specification: One property of operation, include metric specifications. :paramtype service_specification: ~azure.mgmt.keyvault.v2019_09_01.models.ServiceSpecification """ - super(Operation, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display = display self.origin = origin @@ -999,7 +956,7 @@ def __init__( self.service_specification = service_specification -class OperationDisplay(msrest.serialization.Model): +class OperationDisplay(_serialization.Model): """Display metadata associated with the operation. :ivar provider: Service provider: Microsoft Key Vault. @@ -1013,10 +970,10 @@ class OperationDisplay(msrest.serialization.Model): """ _attribute_map = { - 'provider': {'key': 'provider', 'type': 'str'}, - 'resource': {'key': 'resource', 'type': 'str'}, - 'operation': {'key': 'operation', 'type': 'str'}, - 'description': {'key': 'description', 'type': 'str'}, + "provider": {"key": "provider", "type": "str"}, + "resource": {"key": "resource", "type": "str"}, + "operation": {"key": "operation", "type": "str"}, + "description": {"key": "description", "type": "str"}, } def __init__( @@ -1038,14 +995,14 @@ def __init__( :keyword description: Description of operation. :paramtype description: str """ - super(OperationDisplay, self).__init__(**kwargs) + super().__init__(**kwargs) self.provider = provider self.resource = resource self.operation = operation self.description = description -class OperationListResult(msrest.serialization.Model): +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. @@ -1055,29 +1012,23 @@ class OperationListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Operation]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(OperationListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class Permissions(msrest.serialization.Model): +class Permissions(_serialization.Model): """Permissions the identity has for keys, secrets, certificates and storage. :ivar keys: Permissions to keys. @@ -1092,10 +1043,10 @@ class Permissions(msrest.serialization.Model): """ _attribute_map = { - 'keys': {'key': 'keys', 'type': '[str]'}, - 'secrets': {'key': 'secrets', 'type': '[str]'}, - 'certificates': {'key': 'certificates', 'type': '[str]'}, - 'storage': {'key': 'storage', 'type': '[str]'}, + "keys": {"key": "keys", "type": "[str]"}, + "secrets": {"key": "secrets", "type": "[str]"}, + "certificates": {"key": "certificates", "type": "[str]"}, + "storage": {"key": "storage", "type": "[str]"}, } def __init__( @@ -1118,14 +1069,14 @@ def __init__( :keyword storage: Permissions to storage accounts. :paramtype storage: list[str or ~azure.mgmt.keyvault.v2019_09_01.models.StoragePermissions] """ - super(Permissions, self).__init__(**kwargs) + super().__init__(**kwargs) self.keys = keys self.secrets = secrets self.certificates = certificates self.storage = storage -class PrivateEndpoint(msrest.serialization.Model): +class PrivateEndpoint(_serialization.Model): """Private endpoint object properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -1135,20 +1086,16 @@ class PrivateEndpoint(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, + "id": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(PrivateEndpoint, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None @@ -1165,7 +1112,7 @@ class PrivateEndpointConnection(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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 @@ -1175,30 +1122,33 @@ class PrivateEndpointConnection(Resource): :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", "Disconnected". + 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}, + "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'}, + "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__( @@ -1218,14 +1168,14 @@ def __init__( :paramtype private_link_service_connection_state: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateLinkServiceConnectionState """ - super(PrivateEndpointConnection, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class PrivateEndpointConnectionItem(_serialization.Model): """Private endpoint connection item. Variables are only populated by the server, and will be ignored when sending a request. @@ -1240,27 +1190,30 @@ class PrivateEndpointConnectionItem(msrest.serialization.Model): :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", "Disconnected". + 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}, + "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'}, + "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, + 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, @@ -1277,7 +1230,7 @@ def __init__( :paramtype private_link_service_connection_state: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateLinkServiceConnectionState """ - super(PrivateEndpointConnectionItem, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id self.etag = etag self.private_endpoint = private_endpoint @@ -1298,7 +1251,7 @@ class PrivateLinkResource(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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 @@ -1309,43 +1262,38 @@ class PrivateLinkResource(Resource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'location': {'readonly': True}, - 'tags': {'readonly': True}, - 'group_id': {'readonly': True}, - 'required_members': {'readonly': True}, + "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]'}, + "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 - ): + def __init__(self, *, required_zone_names: Optional[List[str]] = None, **kwargs): """ :keyword required_zone_names: Required DNS zone names of the the private link resource. :paramtype required_zone_names: list[str] """ - super(PrivateLinkResource, self).__init__(**kwargs) + super().__init__(**kwargs) self.group_id = None self.required_members = None self.required_zone_names = required_zone_names -class PrivateLinkResourceListResult(msrest.serialization.Model): +class PrivateLinkResourceListResult(_serialization.Model): """A list of private link resources. :ivar value: Array of private link resources. @@ -1353,28 +1301,23 @@ class PrivateLinkResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[PrivateLinkResource]'}, + "value": {"key": "value", "type": "[PrivateLinkResource]"}, } - def __init__( - self, - *, - value: Optional[List["_models.PrivateLinkResource"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs): """ :keyword value: Array of private link resources. :paramtype value: list[~azure.mgmt.keyvault.v2019_09_01.models.PrivateLinkResource] """ - super(PrivateLinkResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class PrivateLinkServiceConnectionState(msrest.serialization.Model): +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", "Disconnected". + 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. @@ -1385,9 +1328,9 @@ class PrivateLinkServiceConnectionState(msrest.serialization.Model): """ _attribute_map = { - 'status': {'key': 'status', 'type': 'str'}, - 'description': {'key': 'description', 'type': 'str'}, - 'actions_required': {'key': 'actionsRequired', 'type': 'str'}, + "status": {"key": "status", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "actions_required": {"key": "actionsRequired", "type": "str"}, } def __init__( @@ -1400,7 +1343,7 @@ 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", "Disconnected". + 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. @@ -1409,13 +1352,13 @@ def __init__( updates on the consumer. :paramtype actions_required: str """ - super(PrivateLinkServiceConnectionState, self).__init__(**kwargs) + super().__init__(**kwargs) self.status = status self.description = description self.actions_required = actions_required -class ResourceListResult(msrest.serialization.Model): +class ResourceListResult(_serialization.Model): """List of vault resources. :ivar value: The list of vault resources. @@ -1425,29 +1368,23 @@ class ResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Resource]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Resource"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(ResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class ServiceSpecification(msrest.serialization.Model): +class ServiceSpecification(_serialization.Model): """One property of operation, include log specifications. :ivar log_specifications: Log specifications of operation. @@ -1458,8 +1395,8 @@ class ServiceSpecification(msrest.serialization.Model): """ _attribute_map = { - 'log_specifications': {'key': 'logSpecifications', 'type': '[LogSpecification]'}, - 'metric_specifications': {'key': 'metricSpecifications', 'type': '[MetricSpecification]'}, + "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, + "metric_specifications": {"key": "metricSpecifications", "type": "[MetricSpecification]"}, } def __init__( @@ -1476,53 +1413,47 @@ def __init__( :paramtype metric_specifications: list[~azure.mgmt.keyvault.v2019_09_01.models.MetricSpecification] """ - super(ServiceSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.log_specifications = log_specifications self.metric_specifications = metric_specifications -class Sku(msrest.serialization.Model): +class Sku(_serialization.Model): """SKU details. All required parameters must be populated in order to send to Azure. - :ivar family: Required. SKU family name. Known values are: "A". + :ivar family: SKU family name. Required. "A" :vartype family: str or ~azure.mgmt.keyvault.v2019_09_01.models.SkuFamily - :ivar name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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}, + "family": {"required": True}, + "name": {"required": True}, } _attribute_map = { - 'family': {'key': 'family', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, + "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 - ): + def __init__(self, *, family: Union[str, "_models.SkuFamily"], name: Union[str, "_models.SkuName"], **kwargs): """ - :keyword family: Required. SKU family name. Known values are: "A". + :keyword family: SKU family name. Required. "A" :paramtype family: str or ~azure.mgmt.keyvault.v2019_09_01.models.SkuFamily - :keyword name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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(Sku, self).__init__(**kwargs) + super().__init__(**kwargs) self.family = family self.name = name -class Vault(msrest.serialization.Model): +class Vault(_serialization.Model): """Resource information with extended details. Variables are only populated by the server, and will be ignored when sending a request. @@ -1537,26 +1468,26 @@ class Vault(msrest.serialization.Model): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :ivar tags: Tags assigned to the key vault resource. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the vault. + :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}, + "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'}, + "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__( @@ -1570,12 +1501,12 @@ def __init__( """ :keyword location: Azure location of the key vault resource. :paramtype location: str - :keyword tags: A set of tags. Tags assigned to the key vault resource. + :keyword tags: Tags assigned to the key vault resource. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2019_09_01.models.VaultProperties """ - super(Vault, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -1584,7 +1515,7 @@ def __init__( self.properties = properties -class VaultAccessPolicyParameters(msrest.serialization.Model): +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. @@ -1599,37 +1530,32 @@ class VaultAccessPolicyParameters(msrest.serialization.Model): :vartype type: str :ivar location: The resource type of the access policy. :vartype location: str - :ivar properties: Required. Properties of the access policy. + :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}, + "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'}, + "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 - ): + def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs): """ - :keyword properties: Required. Properties of the access policy. + :keyword properties: Properties of the access policy. Required. :paramtype properties: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyProperties """ - super(VaultAccessPolicyParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -1637,127 +1563,112 @@ def __init__( self.properties = properties -class VaultAccessPolicyProperties(msrest.serialization.Model): +class VaultAccessPolicyProperties(_serialization.Model): """Properties of the vault access policy. All required parameters must be populated in order to send to Azure. - :ivar access_policies: Required. 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. + :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}, + "access_policies": {"required": True}, } _attribute_map = { - 'access_policies': {'key': 'accessPolicies', 'type': '[AccessPolicyEntry]'}, + "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, } - def __init__( - self, - *, - access_policies: List["_models.AccessPolicyEntry"], - **kwargs - ): + def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwargs): """ - :keyword access_policies: Required. 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. + :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(VaultAccessPolicyProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.access_policies = access_policies -class VaultCheckNameAvailabilityParameters(msrest.serialization.Model): +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 Azure. - :ivar name: Required. The vault name. + :ivar name: The vault name. Required. :vartype name: str - :ivar type: The type of resource, Microsoft.KeyVault/vaults. Has constant value: + :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}, + "name": {"required": True}, + "type": {"required": True, "constant": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, } type = "Microsoft.KeyVault/vaults" - def __init__( - self, - *, - name: str, - **kwargs - ): + def __init__(self, *, name: str, **kwargs): """ - :keyword name: Required. The vault name. + :keyword name: The vault name. Required. :paramtype name: str """ - super(VaultCheckNameAvailabilityParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name -class VaultCreateOrUpdateParameters(msrest.serialization.Model): +class VaultCreateOrUpdateParameters(_serialization.Model): """Parameters for creating or updating a vault. All required parameters must be populated in order to send to Azure. - :ivar location: Required. The supported Azure location where the key vault should be created. + :ivar location: The supported Azure location where the key vault should be created. Required. :vartype location: str - :ivar tags: A set of tags. The tags that will be assigned to the key vault. + :ivar tags: The tags that will be assigned to the key vault. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the vault. + :ivar properties: Properties of the vault. Required. :vartype properties: ~azure.mgmt.keyvault.v2019_09_01.models.VaultProperties """ _validation = { - 'location': {'required': True}, - 'properties': {'required': True}, + "location": {"required": True}, + "properties": {"required": True}, } _attribute_map = { - 'location': {'key': 'location', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'VaultProperties'}, + "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 + self, *, location: str, properties: "_models.VaultProperties", tags: Optional[Dict[str, str]] = None, **kwargs ): """ - :keyword location: Required. The supported Azure location where the key vault should be - created. + :keyword location: The supported Azure location where the key vault should be created. + Required. :paramtype location: str - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :keyword tags: The tags that will be assigned to the key vault. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2019_09_01.models.VaultProperties """ - super(VaultCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.location = location self.tags = tags self.properties = properties -class VaultListResult(msrest.serialization.Model): +class VaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of vaults. @@ -1767,40 +1678,34 @@ class VaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Vault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Vault"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(VaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class VaultPatchParameters(msrest.serialization.Model): +class VaultPatchParameters(_serialization.Model): """Parameters for creating or updating a vault. - :ivar tags: A set of tags. The tags that will be assigned to the key 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'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "VaultPatchProperties"}, } def __init__( @@ -1811,17 +1716,17 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :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(VaultPatchParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class VaultPatchProperties(msrest.serialization.Model): +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 @@ -1854,7 +1759,7 @@ class VaultPatchProperties(msrest.serialization.Model): :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", "default". + 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 @@ -1868,18 +1773,18 @@ class VaultPatchProperties(msrest.serialization.Model): """ _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'}, + "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__( @@ -1931,7 +1836,7 @@ def __init__( <=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", "default". + 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 @@ -1943,7 +1848,7 @@ def __init__( specific network locations. :paramtype network_acls: ~azure.mgmt.keyvault.v2019_09_01.models.NetworkRuleSet """ - super(VaultPatchProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies @@ -1958,17 +1863,17 @@ def __init__( self.network_acls = network_acls -class VaultProperties(msrest.serialization.Model): +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 Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :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 @@ -2003,7 +1908,7 @@ class VaultProperties(msrest.serialization.Model): 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", "default". + 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 @@ -2014,7 +1919,7 @@ class VaultProperties(msrest.serialization.Model): :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", + :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 @@ -2025,29 +1930,32 @@ class VaultProperties(msrest.serialization.Model): """ _validation = { - 'tenant_id': {'required': True}, - 'sku': {'required': True}, - 'hsm_pool_resource_id': {'readonly': True}, - 'private_endpoint_connections': {'readonly': True}, + "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]'}, + "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__( @@ -2060,9 +1968,9 @@ def __init__( 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] = True, - soft_delete_retention_in_days: Optional[int] = 90, - enable_rbac_authorization: Optional[bool] = False, + 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, @@ -2070,10 +1978,10 @@ def __init__( **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :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 @@ -2107,7 +2015,7 @@ def __init__( 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", "default". + 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 @@ -2118,12 +2026,12 @@ def __init__( :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", + :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(VaultProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies @@ -2142,13 +2050,14 @@ def __init__( self.private_endpoint_connections = None -class VirtualNetworkRule(msrest.serialization.Model): +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 Azure. - :ivar id: Required. Full resource id of a vnet subnet, such as + :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. @@ -2156,29 +2065,30 @@ class VirtualNetworkRule(msrest.serialization.Model): """ _validation = { - 'id': {'required': True}, + "id": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'ignore_missing_vnet_service_endpoint': {'key': 'ignoreMissingVnetServiceEndpoint', 'type': 'bool'}, + "id": {"key": "id", "type": "str"}, + "ignore_missing_vnet_service_endpoint": {"key": "ignoreMissingVnetServiceEndpoint", "type": "bool"}, } def __init__( self, *, - id: str, + id: str, # pylint: disable=redefined-builtin ignore_missing_vnet_service_endpoint: Optional[bool] = None, **kwargs ): """ - :keyword id: Required. Full resource id of a vnet subnet, such as + :keyword id: Full resource id of a vnet subnet, such as '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. + 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(VirtualNetworkRule, self).__init__(**kwargs) + 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index a30353f460a6..dbb385b69c88 100644 --- 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 @@ -15,12 +15,13 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'VaultsOperations', - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'Operations', - 'KeysOperations', + "VaultsOperations", + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "Operations", + "KeysOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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 index fc627fb17a15..350bd4e2ed59 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -20,214 +26,176 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - *, - json: Optional[_models.KeyCreateParameters] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_version_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - key_version: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_versions_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class KeysOperations: """ @@ -248,14 +216,15 @@ def __init__(self, *args, **kwargs): 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") - - @distributed_trace + @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 @@ -263,42 +232,120 @@ def create_if_not_exist( subsequent versions, and does not update existing keys. :param resource_group_name: The name of the resource group which contains the specified key - vault. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. + :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. + :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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_if_not_exist( + self, + resource_group_name: str, + vault_name: str, + key_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a + IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.KeyCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Key or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - _json = self._serialize.body(parameters, 'KeyCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "KeyCreateParameters") request = build_create_if_not_exist_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.create_if_not_exist.metadata['url'], + content=_content, + template_url=self.create_if_not_exist.metadata["url"], headers=_headers, params=_params, ) @@ -306,67 +353,61 @@ def create_if_not_exist( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_if_not_exist.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + create_if_not_exist.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> _models.Key: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. + :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. + :param key_name: The name of the key to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -374,64 +415,61 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace - def list( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> Iterable[_models.KeyListResult]: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. + :param vault_name: The name of the vault which contains the keys to be retrieved. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -439,15 +477,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -464,10 +504,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -477,57 +515,53 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore @distributed_trace def get_version( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - key_version: str, - **kwargs: Any + 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. + 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. + :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. + :param key_version: The version of the key to be retrieved. Required. :type key_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_version_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get_version.metadata['url'], + template_url=self.get_version.metadata["url"], headers=_headers, params=_params, ) @@ -535,68 +569,67 @@ def get_version( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_version.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore - + get_version.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore @distributed_trace def list_versions( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> Iterable[_models.KeyListResult]: + 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. + 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. + :param key_name: The name of the key versions to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_versions_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_versions.metadata['url'], + template_url=self.list_versions.metadata["url"], headers=_headers, params=_params, ) @@ -604,16 +637,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_versions_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -630,10 +664,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -643,8 +675,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_versions.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore + list_versions.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore 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 index 3b7d579cc8ff..ac25735a4914 100644 --- 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 @@ -7,10 +7,16 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +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.pipeline.transport import HttpResponse @@ -20,38 +26,34 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request -T = TypeVar('T') + +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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + 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') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class Operations: """ @@ -72,36 +74,35 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> Iterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -109,12 +110,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -131,10 +137,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -144,8 +148,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # type: ignore 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index 023aa174579f..f32c1b712011 100644 --- 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 @@ -6,11 +6,16 @@ # 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, Callable, Dict, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, 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.pipeline.transport import HttpResponse from azure.core.polling import LROPoller, NoPolling, PollingMethod @@ -21,136 +26,132 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_put_request( - subscription_id: str, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, - *, - json: Optional[_models.PrivateEndpointConnection] = None, - content: Any = None, + subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) -def build_delete_request_initial( - subscription_id: str, +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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateEndpointConnectionsOperations: """ @@ -171,48 +172,45 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def get( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -220,10 +218,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -232,64 +229,139 @@ def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - - @distributed_trace + @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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: PrivateEndpointConnection or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - _json = self._serialize.body(properties, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "PrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -297,10 +369,9 @@ def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -308,45 +379,44 @@ def put( 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')) + 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore def _delete_initial( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -354,10 +424,9 @@ def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -367,37 +436,31 @@ def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def begin_delete( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -411,55 +474,48 @@ def begin_delete( of cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 index 4538b89d0713..29b240097437 100644 --- 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 @@ -8,9 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,48 +24,46 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateLinkResourcesOperations: """ @@ -81,43 +84,41 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def list_by_vault( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateLinkResourceListResult, or the result of cls(response) + :return: PrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.PrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] - request = build_list_by_vault_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_vault.metadata['url'], + template_url=self.list_by_vault.metadata["url"], headers=_headers, params=_params, ) @@ -125,22 +126,20 @@ def list_by_vault( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_vault.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore - + list_by_vault.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # 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 index 413fd4c34c7e..15dd1d5a8533 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,485 +28,382 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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_initial( - resource_group_name: str, - vault_name: str, - subscription_id: str, - *, - json: Optional[_models.VaultCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + +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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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, - *, - json: Optional[_models.VaultPatchParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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"], + operation_kind: Union[str, _models.AccessPolicyUpdateKind], subscription_id: str, - *, - json: Optional[_models.VaultAccessPolicyParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + 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 + _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'), + "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + 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 + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_purge_deleted_request_initial( - vault_name: str, - location: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + 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 + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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, *, + filter: Union[str, _models.Enum10], + api_version: Union[str, _models.Enum11], top: Optional[int] = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - filter = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - accept = _headers.pop('Accept', "application/json") + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') + _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') + _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 - ) + _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, - *, - json: Optional[_models.VaultCheckNameAvailabilityParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability") + _url = kwargs.pop( + "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability" + ) path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: """ @@ -521,36 +424,45 @@ def __init__(self, *args, **kwargs): 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") - def _create_or_update_initial( self, resource_group_name: str, vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **kwargs: Any ) -> _models.Vault: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -558,10 +470,9 @@ def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -569,35 +480,109 @@ def _create_or_update_initial( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], + **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -608,20 +593,17 @@ def begin_create_or_update( Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -629,74 +611,140 @@ def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update( + self, + resource_group_name: str, + vault_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Vault + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -705,7 +753,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -713,10 +762,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -724,55 +772,54 @@ def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -780,10 +827,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -793,45 +839,42 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -839,63 +882,140 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace + @overload def update_access_policy( self, resource_group_name: str, vault_name: str, - operation_kind: Union[str, "_models.AccessPolicyUpdateKind"], + 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: VaultAccessPolicyParameters or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.VaultAccessPolicyParameters + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -905,7 +1025,8 @@ def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -913,10 +1034,9 @@ def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -924,57 +1044,58 @@ def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -982,15 +1103,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1007,10 +1130,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1020,45 +1141,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -1066,14 +1185,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1090,10 +1212,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1103,43 +1223,40 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> Iterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1147,13 +1264,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1170,10 +1291,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1183,48 +1302,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace - def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1232,50 +1346,47 @@ def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -1283,10 +1394,9 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -1296,21 +1406,15 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace - def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -1322,99 +1426,93 @@ def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace def list( self, + filter: Union[str, _models.Enum10], + api_version: Union[str, _models.Enum11], top: Optional[int] = None, **kwargs: Any - ) -> Iterable[_models.ResourceListResult]: + ) -> Iterable["_models.Resource"]: """The List operation gets information about the vaults associated with the subscription. + :param filter: The filter to apply on the operation. "resourceType eq + 'Microsoft.KeyVault/vaults'" Required. + :type filter: str or ~azure.mgmt.keyvault.v2019_09_01.models.Enum10 + :param api_version: Azure Resource Manager Api Version. "2015-11-01" Required. + :type api_version: str or ~azure.mgmt.keyvault.v2019_09_01.models.Enum11 :param top: Maximum number of results to return. Default value is None. :type top: int - :keyword filter: The filter to apply on the operation. Default value is "resourceType eq - 'Microsoft.KeyVault/vaults'". Note that overriding this default value may result in unsupported - behavior. - :paramtype filter: str - :keyword api_version: Azure Resource Manager Api Version. Default value is "2015-11-01". Note - that overriding this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2019_09_01.models.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 {}) + _params = kwargs.pop("params", {}) or {} - filter = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, filter=filter, api_version=api_version, top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -1422,15 +1520,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1447,10 +1547,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1460,47 +1558,95 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace + @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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], **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 model type or a IO type. Required. :type vault_name: ~azure.mgmt.keyvault.v2019_09_01.models.VaultCheckNameAvailabilityParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2019_09_01.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2019-09-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1508,22 +1654,20 @@ def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore 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/v2020_04_01_preview/__init__.py index d19915ab3650..731fc6d4be82 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/v2020_04_01_preview/__init__.py @@ -17,7 +17,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_configuration.py index 628f798ff04b..5b041a9829ff 100644 --- 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 @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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: + def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2020-04-01-preview") # type: str + api_version = kwargs.pop("api_version", "2020-04-01-preview") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,23 +47,24 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) self._configure(**kwargs) def _configure( - self, - **kwargs # type: Any + self, **kwargs # type: Any ): # type: (...) -> 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.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs) + 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) + 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 index f97b3b77081e..a14f757d4429 100644 --- 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 @@ -9,20 +9,28 @@ from copy import deepcopy from typing import Any, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import HttpRequest, HttpResponse from azure.mgmt.core import ARMPipelineClient from . import models +from .._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration -from .operations import KeysOperations, ManagedHsmsOperations, Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, SecretsOperations, VaultsOperations +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=too-many-instance-attributes + +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. @@ -42,10 +50,10 @@ class KeyVaultManagementClient: # pylint: disable=too-many-instance-attribute :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. + :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. + 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 @@ -63,41 +71,28 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = ARMPipelineClient(base_url=base_url, config=self._config, **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 - ) - self.vaults = VaultsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize) + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) self.private_endpoint_connections = PrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - self.secrets = SecretsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) + self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize) + self.managed_hsms = ManagedHsmsOperations(self._client, self._config, self._serialize, self._deserialize) - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> HttpResponse: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -106,7 +101,7 @@ def _send_request( >>> response = client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 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 index 7ab96b719ff8..6c0ab68cf0ef 100644 --- 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 @@ -10,20 +10,20 @@ "azure_arm": true, "has_lro_operations": true, "client_side_validation": false, - "sync_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"ARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}", - "async_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"], \"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"AsyncARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}" + "sync_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"ARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \".._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", + "async_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"AsyncARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \"..._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" }, "global_parameters": { "sync": { "credential": { - "signature": "credential, # type: \"TokenCredential\"", - "description": "Credential needed for the client to connect to Azure.", + "signature": "credential: \"TokenCredential\",", + "description": "Credential needed for the client to connect to Azure. Required.", "docstring_type": "~azure.core.credentials.TokenCredential", "required": true }, "subscription_id": { - "signature": "subscription_id, # type: str", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.", + "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 } @@ -31,13 +31,13 @@ "async": { "credential": { "signature": "credential: \"AsyncTokenCredential\",", - "description": "Credential needed for the client to connect to Azure.", + "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.", + "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 } @@ -54,7 +54,7 @@ "required": false }, "base_url": { - "signature": "base_url=\"https://management.azure.com\", # type: str", + "signature": "base_url: str = \"https://management.azure.com\",", "description": "Service URL", "docstring_type": "str", "required": false 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 index 74e48ecd07cf..f99e77fef986 100644 --- 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 @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_vendor.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_vendor.py index 138f663c53a4..9aad73fc743e 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_vendor.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2020_04_01_preview/_vendor.py @@ -7,6 +7,7 @@ from azure.core.pipeline.transport import HttpRequest + def _convert_request(request, files=None): data = request.content if not files else None request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) @@ -14,6 +15,7 @@ def _convert_request(request, files=None): request.set_formdata_body(files) return request + def _format_url_section(template, **kwargs): components = template.split("/") while components: @@ -21,7 +23,5 @@ def _format_url_section(template, **kwargs): return template.format(**kwargs) except KeyError as key: formatted_components = template.split("/") - components = [ - c for c in formatted_components if "{}".format(key.args[0]) not in c - ] + components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] template = "/".join(components) 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 index c1257f7f4e11..e5754a47ce68 100644 --- 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 @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "10.1.0" +VERSION = "1.0.0b1" 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 index 1aa2a0b291a3..c2c64fd1638f 100644 --- 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 @@ -14,7 +14,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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 index 0ebd844af0f1..6d89c3bba95e 100644 --- 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 @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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: + def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2020-04-01-preview") # type: str + api_version = kwargs.pop("api_version", "2020-04-01-preview") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,22 +47,21 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) 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.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) + 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) + 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 index b257f5440087..a40a5d05322d 100644 --- 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 @@ -9,20 +9,28 @@ from copy import deepcopy from typing import Any, Awaitable, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.mgmt.core import AsyncARMPipelineClient from .. import models +from ..._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration -from .operations import KeysOperations, ManagedHsmsOperations, Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, SecretsOperations, VaultsOperations +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=too-many-instance-attributes + +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. @@ -43,10 +51,10 @@ class KeyVaultManagementClient: # pylint: disable=too-many-instance-attribute :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. + :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. + 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 @@ -64,41 +72,28 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **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 - ) - self.vaults = VaultsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize) + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) self.private_endpoint_connections = PrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - self.secrets = SecretsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) + self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize) + self.managed_hsms = ManagedHsmsOperations(self._client, self._config, self._serialize, self._deserialize) - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -107,7 +102,7 @@ def _send_request( >>> response = await client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 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 index 74e48ecd07cf..f99e77fef986 100644 --- 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 @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass 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 index d8c247e50c9e..7107dc727af4 100644 --- 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 @@ -17,14 +17,15 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'KeysOperations', - 'VaultsOperations', - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'Operations', - 'SecretsOperations', - 'ManagedHsmsOperations', + "KeysOperations", + "VaultsOperations", + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "Operations", + "SecretsOperations", + "ManagedHsmsOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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 index a1dbc4dc05b1..f5665e8b5bb7 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,10 +28,18 @@ from ... import models as _models from ..._vendor import _convert_request -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 -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class KeysOperations: """ .. warning:: @@ -43,14 +59,15 @@ def __init__(self, *args, **kwargs) -> None: 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") - - @distributed_trace_async + @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 @@ -58,42 +75,120 @@ async def create_if_not_exist( subsequent versions, and does not update existing keys. :param resource_group_name: The name of the resource group which contains the specified key - vault. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. + :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. + :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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or a + IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - _json = self._serialize.body(parameters, 'KeyCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "KeyCreateParameters") request = build_create_if_not_exist_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.create_if_not_exist.metadata['url'], + content=_content, + template_url=self.create_if_not_exist.metadata["url"], headers=_headers, params=_params, ) @@ -101,67 +196,61 @@ async def create_if_not_exist( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_if_not_exist.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + create_if_not_exist.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> _models.Key: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. + :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. + :param key_name: The name of the key to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -169,65 +258,62 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace - def list( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.KeyListResult]: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. + :param vault_name: The name of the vault which contains the keys to be retrieved. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) + :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.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -235,15 +321,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -260,10 +348,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -273,57 +359,53 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore @distributed_trace_async async def get_version( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - key_version: str, - **kwargs: Any + 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. + 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. + :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. + :param key_version: The version of the key to be retrieved. Required. :type key_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_version_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get_version.metadata['url'], + template_url=self.get_version.metadata["url"], headers=_headers, params=_params, ) @@ -331,69 +413,68 @@ async def get_version( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_version.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore - + get_version.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore @distributed_trace def list_versions( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.KeyListResult]: + 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. + 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. + :param key_name: The name of the key versions to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) + :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.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_versions_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_versions.metadata['url'], + template_url=self.list_versions.metadata["url"], headers=_headers, params=_params, ) @@ -401,16 +482,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_versions_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -427,10 +509,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -440,8 +520,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_versions.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore + list_versions.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore 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 index 55374eab2bda..76360054c257 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,19 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._managed_hsms_operations import build_create_or_update_request_initial, build_delete_request_initial, build_get_request, build_list_by_resource_group_request, build_list_by_subscription_request, build_update_request_initial -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class ManagedHsmsOperations: """ .. warning:: @@ -45,36 +62,41 @@ def __init__(self, *args, **kwargs) -> None: 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") - async def _create_or_update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -82,46 +104,51 @@ async def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - @distributed_trace_async + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. + :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 :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -134,20 +161,86 @@ async def begin_create_or_update( cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], **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 model type + or a IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -155,69 +248,71 @@ async def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore async def _update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_update_request_initial( + 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, - template_url=self._update_initial.metadata['url'], + content=_content, + template_url=self._update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -225,46 +320,88 @@ async def _update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + _update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - - @distributed_trace_async + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to patch the managed HSM Pool. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -277,20 +414,49 @@ async def begin_update( cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def begin_update( + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._update_initial( # type: ignore resource_group_name=resource_group_name, @@ -298,64 +464,59 @@ async def begin_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore async def _delete_initial( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any + self, resource_group_name: str, name: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_delete_request_initial( + request = build_delete_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -363,34 +524,29 @@ async def _delete_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **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) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace_async - async def begin_delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param name: The name of the managed HSM Pool to delete. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -402,92 +558,83 @@ async def begin_delete( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore resource_group_name=resource_group_name, name=name, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> Optional[_models.ManagedHsm]: + 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. + :param name: The name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ManagedHsm, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.ManagedHsm]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.ManagedHsm]] - request = build_get_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -495,10 +642,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -508,56 +654,56 @@ async def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -565,15 +711,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -590,10 +738,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -604,48 +750,45 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -653,14 +796,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -677,10 +823,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -691,8 +835,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore 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 index 5b55d76773dc..225e9e653476 100644 --- 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 @@ -7,9 +7,17 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,9 +28,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._operations import build_list_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class Operations: """ .. warning:: @@ -42,36 +52,36 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> AsyncIterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) + :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.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -79,12 +89,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -101,10 +116,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -114,8 +127,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # type: ignore 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index 0c8283d2bddd..a4fb9a67f67f 100644 --- 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 @@ -6,9 +6,16 @@ # 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, Callable, Dict, Optional, TypeVar, Union, cast - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, 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.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -20,10 +27,16 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._private_endpoint_connections_operations import build_delete_request_initial, build_get_request, build_put_request -T = TypeVar('T') +from ...operations._private_endpoint_connections_operations import ( + build_delete_request, + build_get_request, + build_put_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateEndpointConnectionsOperations: """ .. warning:: @@ -43,48 +56,45 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def get( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -92,10 +102,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -104,64 +113,140 @@ async def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - - @distributed_trace_async + @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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection or + IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - _json = self._serialize.body(properties, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "PrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -169,10 +254,9 @@ async def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -180,45 +264,44 @@ async def put( 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')) + 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore async def _delete_initial( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -226,10 +309,9 @@ async def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -239,37 +321,31 @@ async def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace_async async def begin_delete( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -283,55 +359,48 @@ async def begin_delete( result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 index cd4dc86114a1..c6e1f22267a5 100644 --- 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 @@ -8,7 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -19,9 +26,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._private_link_resources_operations import build_list_by_vault_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateLinkResourcesOperations: """ .. warning:: @@ -41,43 +50,41 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def list_by_vault( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateLinkResourceListResult, or the result of cls(response) + :return: PrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] - request = build_list_by_vault_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_vault.metadata['url'], + template_url=self.list_by_vault.metadata["url"], headers=_headers, params=_params, ) @@ -85,22 +92,20 @@ async def list_by_vault( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_vault.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore - + list_by_vault.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # 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 index fa95da12bf0a..45090165232d 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,10 +28,17 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._secrets_operations import build_create_or_update_request, build_get_request, build_list_request, build_update_request -T = TypeVar('T') +from ...operations._secrets_operations import ( + build_create_or_update_request, + build_get_request, + build_list_request, + build_update_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class SecretsOperations: """ .. warning:: @@ -43,14 +58,15 @@ def __init__(self, *args, **kwargs) -> None: 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") - - @distributed_trace_async + @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 @@ -58,32 +74,111 @@ async def create_or_update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :param secret_name: Name of the secret. Required. :type secret_name: str - :param parameters: Parameters to create or update the secret. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + vault_name: str, + secret_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO + type. Required. + :type parameters: + ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -93,7 +188,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -101,10 +197,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -112,26 +207,27 @@ async def create_or_update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - @distributed_trace_async + @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 @@ -139,31 +235,109 @@ async def update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :param secret_name: Name of the secret. Required. :type secret_name: str - :param parameters: Parameters to patch the secret. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update( + self, + resource_group_name: str, + vault_name: str, + secret_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -173,7 +347,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -181,10 +356,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -192,60 +366,56 @@ async def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - **kwargs: Any - ) -> _models.Secret: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param secret_name: The name of the secret. + :param secret_name: The name of the secret. Required. :type secret_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -253,70 +423,69 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace def list( - self, - resource_group_name: str, - vault_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.SecretListResult]: + 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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SecretListResult or the result of cls(response) + :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.SecretListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SecretListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SecretListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, top=top, - template_url=self.list.metadata['url'], + api_version=api_version, + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -324,16 +493,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -350,10 +520,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -363,8 +531,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore 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 index 123767e09c27..7edd0653b73b 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,25 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._vaults_operations import build_check_name_availability_request, build_create_or_update_request_initial, 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_initial, build_update_access_policy_request, build_update_request -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class VaultsOperations: """ .. warning:: @@ -45,36 +68,45 @@ def __init__(self, *args, **kwargs) -> None: 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") - async def _create_or_update_initial( self, resource_group_name: str, vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **kwargs: Any ) -> _models.Vault: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -82,10 +114,9 @@ async def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -93,35 +124,112 @@ async def _create_or_update_initial( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :param parameters: Parameters to create or update the vault. Is either a model type or a IO + type. Required. :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultCreateOrUpdateParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -133,20 +241,17 @@ async def begin_create_or_update( :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -154,74 +259,140 @@ async def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace_async + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update( + self, + resource_group_name: str, + vault_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -230,7 +401,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -238,10 +410,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -249,55 +420,54 @@ async def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -305,10 +475,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -318,45 +487,42 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -364,64 +530,144 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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: _models.VaultAccessPolicyParameters, + operation_kind: Union[str, _models.AccessPolicyUpdateKind], + parameters: Union[_models.VaultAccessPolicyParameters, IO], **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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :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. + :param parameters: Access policy to merge into the vault. Is either a model type or a IO type. + Required. :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -431,7 +677,8 @@ async def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -439,10 +686,9 @@ async def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -450,58 +696,59 @@ async def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) + :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.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -509,15 +756,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -534,10 +783,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -547,46 +794,44 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) + :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.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -594,14 +839,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -618,10 +866,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -631,43 +877,41 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> AsyncIterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) + :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.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -675,13 +919,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -698,10 +946,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -711,48 +957,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace_async - async def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -760,50 +1001,47 @@ async def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore async def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -811,10 +1049,9 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -824,21 +1061,15 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace_async - async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -850,99 +1081,94 @@ async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace def list( self, + filter: Union[str, _models.Enum16], + api_version: Union[str, _models.Enum17], top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable[_models.ResourceListResult]: + ) -> AsyncIterable["_models.Resource"]: """The List operation gets information about the vaults associated with the subscription. + :param filter: The filter to apply on the operation. "resourceType eq + 'Microsoft.KeyVault/vaults'" Required. + :type filter: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.Enum16 + :param api_version: Azure Resource Manager Api Version. "2015-11-01" Required. + :type api_version: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.Enum17 :param top: Maximum number of results to return. Default value is None. :type top: int - :keyword filter: The filter to apply on the operation. Default value is "resourceType eq - 'Microsoft.KeyVault/vaults'". Note that overriding this default value may result in unsupported - behavior. - :paramtype filter: str - :keyword api_version: Azure Resource Manager Api Version. Default value is "2015-11-01". Note - that overriding this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) + :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.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 {}) + _params = kwargs.pop("params", {}) or {} - filter = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, filter=filter, api_version=api_version, top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -950,15 +1176,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -975,10 +1203,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -988,48 +1214,96 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace_async + @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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def check_name_availability( + self, vault_name: IO, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], **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 model type or a IO type. Required. + :type vault_name: + ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultCheckNameAvailabilityParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1037,22 +1311,20 @@ async def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # 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 index a93739cc85b3..b6e2d2004a8c 100644 --- 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 @@ -63,115 +63,117 @@ from ._models_py3 import VaultProperties from ._models_py3 import VirtualNetworkRule - -from ._key_vault_management_client_enums import ( - AccessPolicyUpdateKind, - ActionsRequired, - CertificatePermissions, - CreateMode, - DeletionRecoveryLevel, - IdentityType, - JsonWebKeyCurveName, - JsonWebKeyOperation, - JsonWebKeyType, - KeyPermissions, - ManagedHsmSkuFamily, - ManagedHsmSkuName, - NetworkRuleAction, - NetworkRuleBypassOptions, - PrivateEndpointConnectionProvisioningState, - PrivateEndpointServiceConnectionStatus, - ProvisioningState, - Reason, - SecretPermissions, - SkuFamily, - SkuName, - StoragePermissions, - VaultProvisioningState, -) +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 Enum16 +from ._key_vault_management_client_enums import Enum17 +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 * # type: ignore # 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', + "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", + "Enum16", + "Enum17", + "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() \ No newline at end of file +_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 index 89b6bbd0af3d..dc98d0990fde 100644 --- 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 @@ -11,24 +11,27 @@ 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. - """ + """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_ENUM = "import" + IMPORT = "import" UPDATE = "update" MANAGECONTACTS = "managecontacts" GETISSUERS = "getissuers" @@ -41,13 +44,14 @@ class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): BACKUP = "backup" RESTORE = "restore" + class CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The vault's create mode to indicate whether the vault need to be recovered or not. - """ + """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 @@ -59,24 +63,37 @@ class DeletionRecoveryLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta): RECOVERABLE = "Recoverable" RECOVERABLE_PROTECTED_SUBSCRIPTION = "Recoverable+ProtectedSubscription" + +class Enum16(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Enum16.""" + + RESOURCE_TYPE_EQ_MICROSOFT_KEY_VAULT_VAULTS_ = "resourceType eq 'Microsoft.KeyVault/vaults'" + + +class Enum17(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Enum17.""" + + TWO_THOUSAND_FIFTEEN11_01 = "2015-11-01" + + class IdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of identity. - """ + """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. - """ + """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. @@ -88,18 +105,20 @@ class JsonWebKeyOperation(str, Enum, metaclass=CaseInsensitiveEnumMeta): VERIFY = "verify" WRAP_KEY = "wrapKey" UNWRAP_KEY = "unwrapKey" - IMPORT_ENUM = "import" + IMPORT = "import" + class JsonWebKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of the key. For valid values, see JsonWebKeyType. - """ + """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" @@ -111,26 +130,27 @@ class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): LIST = "list" CREATE = "create" UPDATE = "update" - IMPORT_ENUM = "import" + IMPORT = "import" DELETE = "delete" BACKUP = "backup" RESTORE = "restore" RECOVER = "recover" PURGE = "purge" + class ManagedHsmSkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU Family of the managed HSM Pool - """ + """SKU Family of the managed HSM Pool.""" B = "B" + class ManagedHsmSkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU of the managed HSM Pool - """ + """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. @@ -139,6 +159,7 @@ class NetworkRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta): 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'. @@ -147,9 +168,9 @@ class NetworkRuleBypassOptions(str, Enum, metaclass=CaseInsensitiveEnumMeta): AZURE_SERVICES = "AzureServices" NONE = "None" + class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The current provisioning state. - """ + """The current provisioning state.""" SUCCEEDED = "Succeeded" CREATING = "Creating" @@ -158,18 +179,18 @@ class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsens FAILED = "Failed" DISCONNECTED = "Disconnected" + class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The private endpoint connection status. - """ + """The private endpoint connection status.""" PENDING = "Pending" APPROVED = "Approved" REJECTED = "Rejected" DISCONNECTED = "Disconnected" + class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state. - """ + """Provisioning state.""" #: The managed HSM Pool has been full provisioned. SUCCEEDED = "Succeeded" @@ -188,6 +209,7 @@ class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): #: The managed HSM pool is being restored from full HSM backup. RESTORING = "Restoring" + 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. @@ -196,7 +218,9 @@ class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta): ACCOUNT_NAME_INVALID = "AccountNameInvalid" ALREADY_EXISTS = "AlreadyExists" + class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """SecretPermissions.""" GET = "get" LIST = "list" @@ -207,20 +231,22 @@ class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): RECOVER = "recover" PURGE = "purge" + class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU family name - """ + """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. - """ + """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" @@ -237,9 +263,9 @@ class StoragePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): GETSAS = "getsas" DELETESAS = "deletesas" + class VaultProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state of the vault. - """ + """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 index 1cc1320b2c49..8f9930024f40 100644 --- 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 @@ -1,4 +1,5 @@ # 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. @@ -9,43 +10,42 @@ import datetime from typing import Dict, List, Optional, TYPE_CHECKING, Union -from azure.core.exceptions import HttpResponseError -import msrest.serialization +from ... import _serialization if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - import __init__ as _models + from .. import models as _models -class AccessPolicyEntry(msrest.serialization.Model): +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 Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and certificates. + :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}, + "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'}, + "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__( @@ -58,27 +58,27 @@ def __init__( **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and - certificates. + :keyword permissions: Permissions the identity has for keys, secrets and certificates. + Required. :paramtype permissions: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Permissions """ - super(AccessPolicyEntry, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.object_id = object_id self.application_id = application_id self.permissions = permissions -class Attributes(msrest.serialization.Model): +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. @@ -96,16 +96,16 @@ class Attributes(msrest.serialization.Model): """ _validation = { - 'created': {'readonly': True}, - 'updated': {'readonly': True}, + "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'}, + "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__( @@ -124,7 +124,7 @@ def __init__( :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. :paramtype expires: ~datetime.datetime """ - super(Attributes, self).__init__(**kwargs) + super().__init__(**kwargs) self.enabled = enabled self.not_before = not_before self.expires = expires @@ -132,7 +132,7 @@ def __init__( self.updated = None -class CheckNameAvailabilityResult(msrest.serialization.Model): +class CheckNameAvailabilityResult(_serialization.Model): """The CheckNameAvailability operation response. Variables are only populated by the server, and will be ignored when sending a request. @@ -142,37 +142,33 @@ class CheckNameAvailabilityResult(msrest.serialization.Model): 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", "AlreadyExists". + 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}, + "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'}, + "name_available": {"key": "nameAvailable", "type": "bool"}, + "reason": {"key": "reason", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(CheckNameAvailabilityResult, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.name_available = None self.reason = None self.message = None -class CloudErrorBody(msrest.serialization.Model): +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. @@ -183,17 +179,11 @@ class CloudErrorBody(msrest.serialization.Model): """ _attribute_map = { - 'code': {'key': 'code', 'type': 'str'}, - 'message': {'key': 'message', 'type': 'str'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - *, - code: Optional[str] = None, - message: Optional[str] = None, - **kwargs - ): + def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs): """ :keyword code: Error code. This is a mnemonic that can be consumed programmatically. :paramtype code: str @@ -201,12 +191,12 @@ def __init__( with service version. :paramtype message: str """ - super(CloudErrorBody, self).__init__(**kwargs) + super().__init__(**kwargs) self.code = code self.message = message -class DeletedVault(msrest.serialization.Model): +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. @@ -222,36 +212,31 @@ class DeletedVault(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "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'}, + "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 - ): + def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs): """ :keyword properties: Properties of the vault. :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.DeletedVaultProperties """ - super(DeletedVault, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None self.properties = properties -class DeletedVaultListResult(msrest.serialization.Model): +class DeletedVaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of deleted vaults. @@ -261,16 +246,12 @@ class DeletedVaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DeletedVault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.DeletedVault"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of deleted vaults. @@ -278,12 +259,12 @@ def __init__( :keyword next_link: The URL to get the next set of deleted vaults. :paramtype next_link: str """ - super(DeletedVaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class DeletedVaultProperties(msrest.serialization.Model): +class DeletedVaultProperties(_serialization.Model): """Properties of the deleted vault. Variables are only populated by the server, and will be ignored when sending a request. @@ -296,37 +277,33 @@ class DeletedVaultProperties(msrest.serialization.Model): :vartype deletion_date: ~datetime.datetime :ivar scheduled_purge_date: The scheduled purged date. :vartype scheduled_purge_date: ~datetime.datetime - :ivar tags: A set of tags. Tags of the original vault. + :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}, + "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'}, + "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 - ): - """ - """ - super(DeletedVaultProperties, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.vault_id = None self.location = None self.deletion_date = None @@ -335,7 +312,7 @@ def __init__( self.purge_protection_enabled = None -class DimensionProperties(msrest.serialization.Model): +class DimensionProperties(_serialization.Model): """Type of operation: get, read, delete, etc. :ivar name: Name of dimension. @@ -348,9 +325,9 @@ class DimensionProperties(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'to_be_exported_for_shoebox': {'key': 'toBeExportedForShoebox', 'type': 'bool'}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "to_be_exported_for_shoebox": {"key": "toBeExportedForShoebox", "type": "bool"}, } def __init__( @@ -370,13 +347,13 @@ def __init__( exported for shoebox. :paramtype to_be_exported_for_shoebox: bool """ - super(DimensionProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.to_be_exported_for_shoebox = to_be_exported_for_shoebox -class Error(msrest.serialization.Model): +class Error(_serialization.Model): """The server error. Variables are only populated by the server, and will be ignored when sending a request. @@ -390,63 +367,54 @@ class Error(msrest.serialization.Model): """ _validation = { - 'code': {'readonly': True}, - 'message': {'readonly': True}, - 'inner_error': {'readonly': True}, + "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'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, + "inner_error": {"key": "innererror", "type": "Error"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(Error, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.code = None self.message = None self.inner_error = None -class IPRule(msrest.serialization.Model): +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 Azure. - :ivar value: Required. 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). + :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}, + "value": {"required": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, + "value": {"key": "value", "type": "str"}, } - def __init__( - self, - *, - value: str, - **kwargs - ): + def __init__(self, *, value: str, **kwargs): """ - :keyword value: Required. 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). + :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(IPRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class Resource(msrest.serialization.Model): +class Resource(_serialization.Model): """Key Vault resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -459,33 +427,29 @@ class Resource(msrest.serialization.Model): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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}, + "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}'}, + "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 - ): - """ - """ - super(Resource, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -493,7 +457,7 @@ def __init__( self.tags = None -class Key(Resource): +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. @@ -506,12 +470,12 @@ class Key(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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", "RSA-HSM". + "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 @@ -519,7 +483,7 @@ class Key(Resource): :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", "P-256K". + 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 @@ -528,28 +492,28 @@ class Key(Resource): """ _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}, + "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'}, + "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__( @@ -566,7 +530,7 @@ def __init__( :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", "RSA-HSM". + "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 @@ -574,11 +538,11 @@ def __init__( :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", "P-256K". + 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(Key, self).__init__(**kwargs) + super().__init__(**kwargs) self.attributes = attributes self.kty = kty self.key_ops = key_ops @@ -588,7 +552,7 @@ def __init__( self.key_uri_with_version = None -class KeyAttributes(msrest.serialization.Model): +class KeyAttributes(_serialization.Model): """The attributes of the key. Variables are only populated by the server, and will be ignored when sending a request. @@ -596,35 +560,35 @@ class KeyAttributes(msrest.serialization.Model): :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: long + :vartype not_before: int :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: long + :vartype expires: int :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: long + :vartype created: int :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: long + :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", + 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}, + "created": {"readonly": True}, + "updated": {"readonly": True}, + "recovery_level": {"readonly": True}, } _attribute_map = { - 'enabled': {'key': 'enabled', 'type': 'bool'}, - 'not_before': {'key': 'nbf', 'type': 'long'}, - 'expires': {'key': 'exp', 'type': 'long'}, - 'created': {'key': 'created', 'type': 'long'}, - 'updated': {'key': 'updated', 'type': 'long'}, - 'recovery_level': {'key': 'recoveryLevel', 'type': 'str'}, + "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__( @@ -639,11 +603,11 @@ def __init__( :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: long + :paramtype not_before: int :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :paramtype expires: long + :paramtype expires: int """ - super(KeyAttributes, self).__init__(**kwargs) + super().__init__(**kwargs) self.enabled = enabled self.not_before = not_before self.expires = expires @@ -652,45 +616,39 @@ def __init__( self.recovery_level = None -class KeyCreateParameters(msrest.serialization.Model): +class KeyCreateParameters(_serialization.Model): """The parameters used to create a key. All required parameters must be populated in order to send to Azure. - :ivar tags: A set of tags. The tags that will be assigned to the key. + :ivar tags: The tags that will be assigned to the key. :vartype tags: dict[str, str] - :ivar properties: Required. The properties of the key to be created. + :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}, + "properties": {"required": True}, } _attribute_map = { - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'KeyProperties'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "KeyProperties"}, } - def __init__( - self, - *, - properties: "_models.KeyProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs - ): + def __init__(self, *, properties: "_models.KeyProperties", tags: Optional[Dict[str, str]] = None, **kwargs): """ - :keyword tags: A set of tags. The tags that will be assigned to the key. + :keyword tags: The tags that will be assigned to the key. :paramtype tags: dict[str, str] - :keyword properties: Required. The properties of the key to be created. + :keyword properties: The properties of the key to be created. Required. :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyProperties """ - super(KeyCreateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class KeyListResult(msrest.serialization.Model): +class KeyListResult(_serialization.Model): """The page of keys. :ivar value: The key resources. @@ -700,29 +658,23 @@ class KeyListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Key]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Key"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(KeyListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class KeyProperties(msrest.serialization.Model): +class KeyProperties(_serialization.Model): """The properties of the key. Variables are only populated by the server, and will be ignored when sending a request. @@ -730,7 +682,7 @@ class KeyProperties(msrest.serialization.Model): :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", "RSA-HSM". + "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 @@ -738,7 +690,7 @@ class KeyProperties(msrest.serialization.Model): :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", "P-256K". + 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 @@ -747,18 +699,18 @@ class KeyProperties(msrest.serialization.Model): """ _validation = { - 'key_uri': {'readonly': True}, - 'key_uri_with_version': {'readonly': True}, + "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'}, + "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__( @@ -775,7 +727,7 @@ def __init__( :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", "RSA-HSM". + "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 @@ -783,11 +735,11 @@ def __init__( :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", "P-256K". + 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(KeyProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.attributes = attributes self.kty = kty self.key_ops = key_ops @@ -797,7 +749,7 @@ def __init__( self.key_uri_with_version = None -class LogSpecification(msrest.serialization.Model): +class LogSpecification(_serialization.Model): """Log specification of operation. :ivar name: Name of log specification. @@ -809,9 +761,9 @@ class LogSpecification(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'blob_duration': {'key': 'blobDuration', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "blob_duration": {"key": "blobDuration", "type": "str"}, } def __init__( @@ -830,13 +782,13 @@ def __init__( :keyword blob_duration: Blob duration of specification. :paramtype blob_duration: str """ - super(LogSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.blob_duration = blob_duration -class ManagedHsmResource(msrest.serialization.Model): +class ManagedHsmResource(_serialization.Model): """Managed HSM resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -851,23 +803,23 @@ class ManagedHsmResource(msrest.serialization.Model): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "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}'}, + "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__( @@ -883,10 +835,10 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :keyword tags: Resource tags. :paramtype tags: dict[str, str] """ - super(ManagedHsmResource, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -910,26 +862,26 @@ class ManagedHsm(ManagedHsmResource): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :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}, + "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'}, + "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__( @@ -946,16 +898,16 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :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(ManagedHsm, self).__init__(location=location, sku=sku, tags=tags, **kwargs) + super().__init__(location=location, sku=sku, tags=tags, **kwargs) self.properties = properties -class ManagedHsmError(msrest.serialization.Model): +class ManagedHsmError(_serialization.Model): """The error exception. Variables are only populated by the server, and will be ignored when sending a request. @@ -965,24 +917,20 @@ class ManagedHsmError(msrest.serialization.Model): """ _validation = { - 'error': {'readonly': True}, + "error": {"readonly": True}, } _attribute_map = { - 'error': {'key': 'error', 'type': 'Error'}, + "error": {"key": "error", "type": "Error"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(ManagedHsmError, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.error = None -class ManagedHsmListResult(msrest.serialization.Model): +class ManagedHsmListResult(_serialization.Model): """List of managed HSM Pools. :ivar value: The list of managed HSM Pools. @@ -992,16 +940,12 @@ class ManagedHsmListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[ManagedHsm]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.ManagedHsm"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of managed HSM Pools. @@ -1009,12 +953,12 @@ def __init__( :keyword next_link: The URL to get the next set of managed HSM Pools. :paramtype next_link: str """ - super(ManagedHsmListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class ManagedHsmProperties(msrest.serialization.Model): +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. @@ -1041,32 +985,32 @@ class ManagedHsmProperties(msrest.serialization.Model): 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", "default". + 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", "Restoring". + "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}, + "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'}, + "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__( @@ -1074,9 +1018,9 @@ def __init__( *, tenant_id: Optional[str] = None, initial_admin_object_ids: Optional[List[str]] = None, - enable_soft_delete: Optional[bool] = True, - soft_delete_retention_in_days: Optional[int] = 90, - enable_purge_protection: Optional[bool] = True, + 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 ): @@ -1102,10 +1046,10 @@ def __init__( 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", "default". + 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(ManagedHsmProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.initial_admin_object_ids = initial_admin_object_ids self.hsm_uri = None @@ -1117,48 +1061,48 @@ def __init__( self.provisioning_state = None -class ManagedHsmSku(msrest.serialization.Model): +class ManagedHsmSku(_serialization.Model): """SKU details. All required parameters must be populated in order to send to Azure. - :ivar family: Required. SKU Family of the managed HSM Pool. Known values are: "B". + :ivar family: SKU Family of the managed HSM Pool. Required. "B" :vartype family: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmSkuFamily - :ivar name: Required. SKU of the managed HSM Pool. Known values are: "Standard_B1", + :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}, + "family": {"required": True}, + "name": {"required": True}, } _attribute_map = { - 'family': {'key': 'family', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, + "family": {"key": "family", "type": "str"}, + "name": {"key": "name", "type": "str"}, } def __init__( self, *, - family: Union[str, "_models.ManagedHsmSkuFamily"] = "B", + family: Union[str, "_models.ManagedHsmSkuFamily"], name: Union[str, "_models.ManagedHsmSkuName"], **kwargs ): """ - :keyword family: Required. SKU Family of the managed HSM Pool. Known values are: "B". + :keyword family: SKU Family of the managed HSM Pool. Required. "B" :paramtype family: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsmSkuFamily - :keyword name: Required. SKU of the managed HSM Pool. Known values are: "Standard_B1", + :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(ManagedHsmSku, self).__init__(**kwargs) + super().__init__(**kwargs) self.family = family self.name = name -class MetricSpecification(msrest.serialization.Model): +class MetricSpecification(_serialization.Model): # pylint: disable=too-many-instance-attributes """Metric specification of operation. :ivar name: Name of metric specification. @@ -1187,17 +1131,17 @@ class MetricSpecification(msrest.serialization.Model): """ _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'}, + "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__( @@ -1242,7 +1186,7 @@ def __init__( :keyword internal_metric_name: The internal metric name. :paramtype internal_metric_name: str """ - super(MetricSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.display_description = display_description @@ -1256,17 +1200,17 @@ def __init__( self.internal_metric_name = internal_metric_name -class NetworkRuleSet(msrest.serialization.Model): +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", + '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", "Deny". + "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. @@ -1277,10 +1221,10 @@ class NetworkRuleSet(msrest.serialization.Model): """ _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]'}, + "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__( @@ -1294,13 +1238,13 @@ 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", + '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", "Deny". + 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. @@ -1309,14 +1253,14 @@ def __init__( :paramtype virtual_network_rules: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.VirtualNetworkRule] """ - super(NetworkRuleSet, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class Operation(_serialization.Model): """Key Vault REST API operation definition. :ivar name: Operation name: {provider}/{resource}/{operation}. @@ -1333,11 +1277,11 @@ class Operation(msrest.serialization.Model): """ _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'}, + "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__( @@ -1363,7 +1307,7 @@ def __init__( :paramtype service_specification: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ServiceSpecification """ - super(Operation, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display = display self.origin = origin @@ -1371,7 +1315,7 @@ def __init__( self.service_specification = service_specification -class OperationDisplay(msrest.serialization.Model): +class OperationDisplay(_serialization.Model): """Display metadata associated with the operation. :ivar provider: Service provider: Microsoft Key Vault. @@ -1385,10 +1329,10 @@ class OperationDisplay(msrest.serialization.Model): """ _attribute_map = { - 'provider': {'key': 'provider', 'type': 'str'}, - 'resource': {'key': 'resource', 'type': 'str'}, - 'operation': {'key': 'operation', 'type': 'str'}, - 'description': {'key': 'description', 'type': 'str'}, + "provider": {"key": "provider", "type": "str"}, + "resource": {"key": "resource", "type": "str"}, + "operation": {"key": "operation", "type": "str"}, + "description": {"key": "description", "type": "str"}, } def __init__( @@ -1410,14 +1354,14 @@ def __init__( :keyword description: Description of operation. :paramtype description: str """ - super(OperationDisplay, self).__init__(**kwargs) + super().__init__(**kwargs) self.provider = provider self.resource = resource self.operation = operation self.description = description -class OperationListResult(msrest.serialization.Model): +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. @@ -1427,29 +1371,23 @@ class OperationListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Operation]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(OperationListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class Permissions(msrest.serialization.Model): +class Permissions(_serialization.Model): """Permissions the identity has for keys, secrets, certificates and storage. :ivar keys: Permissions to keys. @@ -1466,10 +1404,10 @@ class Permissions(msrest.serialization.Model): """ _attribute_map = { - 'keys': {'key': 'keys', 'type': '[str]'}, - 'secrets': {'key': 'secrets', 'type': '[str]'}, - 'certificates': {'key': 'certificates', 'type': '[str]'}, - 'storage': {'key': 'storage', 'type': '[str]'}, + "keys": {"key": "keys", "type": "[str]"}, + "secrets": {"key": "secrets", "type": "[str]"}, + "certificates": {"key": "certificates", "type": "[str]"}, + "storage": {"key": "storage", "type": "[str]"}, } def __init__( @@ -1494,14 +1432,14 @@ def __init__( :paramtype storage: list[str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.StoragePermissions] """ - super(Permissions, self).__init__(**kwargs) + super().__init__(**kwargs) self.keys = keys self.secrets = secrets self.certificates = certificates self.storage = storage -class PrivateEndpoint(msrest.serialization.Model): +class PrivateEndpoint(_serialization.Model): """Private endpoint object properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -1511,20 +1449,16 @@ class PrivateEndpoint(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, + "id": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(PrivateEndpoint, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None @@ -1541,7 +1475,7 @@ class PrivateEndpointConnection(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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 @@ -1551,30 +1485,33 @@ class PrivateEndpointConnection(Resource): :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", "Disconnected". + 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}, + "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'}, + "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__( @@ -1594,14 +1531,14 @@ def __init__( :paramtype private_link_service_connection_state: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateLinkServiceConnectionState """ - super(PrivateEndpointConnection, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class PrivateEndpointConnectionItem(_serialization.Model): """Private endpoint connection item. Variables are only populated by the server, and will be ignored when sending a request. @@ -1616,27 +1553,30 @@ class PrivateEndpointConnectionItem(msrest.serialization.Model): :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", "Disconnected". + 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}, + "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'}, + "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, + 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, @@ -1653,7 +1593,7 @@ def __init__( :paramtype private_link_service_connection_state: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateLinkServiceConnectionState """ - super(PrivateEndpointConnectionItem, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id self.etag = etag self.private_endpoint = private_endpoint @@ -1674,7 +1614,7 @@ class PrivateLinkResource(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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 @@ -1685,43 +1625,38 @@ class PrivateLinkResource(Resource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'location': {'readonly': True}, - 'tags': {'readonly': True}, - 'group_id': {'readonly': True}, - 'required_members': {'readonly': True}, + "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]'}, + "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 - ): + def __init__(self, *, required_zone_names: Optional[List[str]] = None, **kwargs): """ :keyword required_zone_names: Required DNS zone names of the the private link resource. :paramtype required_zone_names: list[str] """ - super(PrivateLinkResource, self).__init__(**kwargs) + super().__init__(**kwargs) self.group_id = None self.required_members = None self.required_zone_names = required_zone_names -class PrivateLinkResourceListResult(msrest.serialization.Model): +class PrivateLinkResourceListResult(_serialization.Model): """A list of private link resources. :ivar value: Array of private link resources. @@ -1729,42 +1664,37 @@ class PrivateLinkResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[PrivateLinkResource]'}, + "value": {"key": "value", "type": "[PrivateLinkResource]"}, } - def __init__( - self, - *, - value: Optional[List["_models.PrivateLinkResource"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs): """ :keyword value: Array of private link resources. :paramtype value: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateLinkResource] """ - super(PrivateLinkResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class PrivateLinkServiceConnectionState(msrest.serialization.Model): +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", "Disconnected". + 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. Known values are: "None". + 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'}, + "status": {"key": "status", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "actions_required": {"key": "actionsRequired", "type": "str"}, } def __init__( @@ -1777,23 +1707,23 @@ 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", "Disconnected". + 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. Known values are: "None". + updates on the consumer. "None" :paramtype actions_required: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.ActionsRequired """ - super(PrivateLinkServiceConnectionState, self).__init__(**kwargs) + super().__init__(**kwargs) self.status = status self.description = description self.actions_required = actions_required -class ResourceListResult(msrest.serialization.Model): +class ResourceListResult(_serialization.Model): """List of vault resources. :ivar value: The list of vault resources. @@ -1803,24 +1733,18 @@ class ResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Resource]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Resource"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(ResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link @@ -1840,41 +1764,36 @@ class Secret(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :ivar tags: Tags assigned to the key vault resource. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the secret. + :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}, + "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'}, + "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 - ): + def __init__(self, *, properties: "_models.SecretProperties", **kwargs): """ - :keyword properties: Required. Properties of the secret. + :keyword properties: Properties of the secret. Required. :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretProperties """ - super(Secret, self).__init__(**kwargs) + super().__init__(**kwargs) self.properties = properties @@ -1896,16 +1815,16 @@ class SecretAttributes(Attributes): """ _validation = { - 'created': {'readonly': True}, - 'updated': {'readonly': True}, + "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'}, + "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__( @@ -1924,48 +1843,42 @@ def __init__( :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. :paramtype expires: ~datetime.datetime """ - super(SecretAttributes, self).__init__(enabled=enabled, not_before=not_before, expires=expires, **kwargs) + super().__init__(enabled=enabled, not_before=not_before, expires=expires, **kwargs) -class SecretCreateOrUpdateParameters(msrest.serialization.Model): +class SecretCreateOrUpdateParameters(_serialization.Model): """Parameters for creating or updating a secret. All required parameters must be populated in order to send to Azure. - :ivar tags: A set of tags. The tags that will be assigned to the secret. + :ivar tags: The tags that will be assigned to the secret. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the secret. + :ivar properties: Properties of the secret. Required. :vartype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretProperties """ _validation = { - 'properties': {'required': True}, + "properties": {"required": True}, } _attribute_map = { - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'SecretProperties'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "SecretProperties"}, } - def __init__( - self, - *, - properties: "_models.SecretProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs - ): + def __init__(self, *, properties: "_models.SecretProperties", tags: Optional[Dict[str, str]] = None, **kwargs): """ - :keyword tags: A set of tags. The tags that will be assigned to the secret. + :keyword tags: The tags that will be assigned to the secret. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the secret. + :keyword properties: Properties of the secret. Required. :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretProperties """ - super(SecretCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class SecretListResult(msrest.serialization.Model): +class SecretListResult(_serialization.Model): """List of secrets. :ivar value: The list of secrets. @@ -1975,40 +1888,34 @@ class SecretListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Secret]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Secret"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(SecretListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class SecretPatchParameters(msrest.serialization.Model): +class SecretPatchParameters(_serialization.Model): """Parameters for patching a secret. - :ivar tags: A set of tags. The tags that will be assigned to the 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'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "SecretPatchProperties"}, } def __init__( @@ -2019,17 +1926,17 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. The tags that will be assigned to the secret. + :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(SecretPatchParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class SecretPatchProperties(msrest.serialization.Model): +class SecretPatchProperties(_serialization.Model): """Properties of the secret. :ivar value: The value of the secret. @@ -2041,9 +1948,9 @@ class SecretPatchProperties(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, - 'content_type': {'key': 'contentType', 'type': 'str'}, - 'attributes': {'key': 'attributes', 'type': 'SecretAttributes'}, + "value": {"key": "value", "type": "str"}, + "content_type": {"key": "contentType", "type": "str"}, + "attributes": {"key": "attributes", "type": "SecretAttributes"}, } def __init__( @@ -2062,13 +1969,13 @@ def __init__( :keyword attributes: The attributes of the secret. :paramtype attributes: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretAttributes """ - super(SecretPatchProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.content_type = content_type self.attributes = attributes -class SecretProperties(msrest.serialization.Model): +class SecretProperties(_serialization.Model): """Properties of the secret. Variables are only populated by the server, and will be ignored when sending a request. @@ -2088,16 +1995,16 @@ class SecretProperties(msrest.serialization.Model): """ _validation = { - 'secret_uri': {'readonly': True}, - 'secret_uri_with_version': {'readonly': True}, + "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'}, + "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__( @@ -2118,7 +2025,7 @@ def __init__( :keyword attributes: The attributes of the secret. :paramtype attributes: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretAttributes """ - super(SecretProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.content_type = content_type self.attributes = attributes @@ -2126,7 +2033,7 @@ def __init__( self.secret_uri_with_version = None -class ServiceSpecification(msrest.serialization.Model): +class ServiceSpecification(_serialization.Model): """One property of operation, include log specifications. :ivar log_specifications: Log specifications of operation. @@ -2138,8 +2045,8 @@ class ServiceSpecification(msrest.serialization.Model): """ _attribute_map = { - 'log_specifications': {'key': 'logSpecifications', 'type': '[LogSpecification]'}, - 'metric_specifications': {'key': 'metricSpecifications', 'type': '[MetricSpecification]'}, + "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, + "metric_specifications": {"key": "metricSpecifications", "type": "[MetricSpecification]"}, } def __init__( @@ -2157,66 +2064,60 @@ def __init__( :paramtype metric_specifications: list[~azure.mgmt.keyvault.v2020_04_01_preview.models.MetricSpecification] """ - super(ServiceSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.log_specifications = log_specifications self.metric_specifications = metric_specifications -class Sku(msrest.serialization.Model): +class Sku(_serialization.Model): """SKU details. All required parameters must be populated in order to send to Azure. - :ivar family: Required. SKU family name. Known values are: "A". + :ivar family: SKU family name. Required. "A" :vartype family: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.SkuFamily - :ivar name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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}, + "family": {"required": True}, + "name": {"required": True}, } _attribute_map = { - 'family': {'key': 'family', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, + "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 - ): + def __init__(self, *, family: Union[str, "_models.SkuFamily"], name: Union[str, "_models.SkuName"], **kwargs): """ - :keyword family: Required. SKU family name. Known values are: "A". + :keyword family: SKU family name. Required. "A" :paramtype family: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.SkuFamily - :keyword name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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(Sku, self).__init__(**kwargs) + super().__init__(**kwargs) self.family = family self.name = name -class SystemData(msrest.serialization.Model): +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", "Key". + "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", "Key". + 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). @@ -2224,12 +2125,12 @@ class SystemData(msrest.serialization.Model): """ _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'}, + "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__( @@ -2247,20 +2148,20 @@ def __init__( :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", "Key". + 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", "Key". + 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(SystemData, self).__init__(**kwargs) + super().__init__(**kwargs) self.created_by = created_by self.created_by_type = created_by_type self.created_at = created_at @@ -2269,7 +2170,7 @@ def __init__( self.last_modified_at = last_modified_at -class Vault(msrest.serialization.Model): +class Vault(_serialization.Model): """Resource information with extended details. Variables are only populated by the server, and will be ignored when sending a request. @@ -2284,30 +2185,30 @@ class Vault(msrest.serialization.Model): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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: Required. Properties of the vault. + :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}, + "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'}, + "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__( @@ -2321,12 +2222,12 @@ def __init__( """ :keyword location: Azure location of the key vault resource. :paramtype location: str - :keyword tags: A set of tags. Tags assigned to the key vault resource. + :keyword tags: Tags assigned to the key vault resource. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultProperties """ - super(Vault, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -2336,7 +2237,7 @@ def __init__( self.properties = properties -class VaultAccessPolicyParameters(msrest.serialization.Model): +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. @@ -2351,39 +2252,34 @@ class VaultAccessPolicyParameters(msrest.serialization.Model): :vartype type: str :ivar location: The resource type of the access policy. :vartype location: str - :ivar properties: Required. Properties of the access policy. + :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}, + "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'}, + "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 - ): + def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs): """ - :keyword properties: Required. Properties of the access policy. + :keyword properties: Properties of the access policy. Required. :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyProperties """ - super(VaultAccessPolicyParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -2391,129 +2287,114 @@ def __init__( self.properties = properties -class VaultAccessPolicyProperties(msrest.serialization.Model): +class VaultAccessPolicyProperties(_serialization.Model): """Properties of the vault access policy. All required parameters must be populated in order to send to Azure. - :ivar access_policies: Required. 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. + :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}, + "access_policies": {"required": True}, } _attribute_map = { - 'access_policies': {'key': 'accessPolicies', 'type': '[AccessPolicyEntry]'}, + "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, } - def __init__( - self, - *, - access_policies: List["_models.AccessPolicyEntry"], - **kwargs - ): + def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwargs): """ - :keyword access_policies: Required. 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. + :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(VaultAccessPolicyProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.access_policies = access_policies -class VaultCheckNameAvailabilityParameters(msrest.serialization.Model): +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 Azure. - :ivar name: Required. The vault name. + :ivar name: The vault name. Required. :vartype name: str - :ivar type: The type of resource, Microsoft.KeyVault/vaults. Has constant value: + :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}, + "name": {"required": True}, + "type": {"required": True, "constant": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, } type = "Microsoft.KeyVault/vaults" - def __init__( - self, - *, - name: str, - **kwargs - ): + def __init__(self, *, name: str, **kwargs): """ - :keyword name: Required. The vault name. + :keyword name: The vault name. Required. :paramtype name: str """ - super(VaultCheckNameAvailabilityParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name -class VaultCreateOrUpdateParameters(msrest.serialization.Model): +class VaultCreateOrUpdateParameters(_serialization.Model): """Parameters for creating or updating a vault. All required parameters must be populated in order to send to Azure. - :ivar location: Required. The supported Azure location where the key vault should be created. + :ivar location: The supported Azure location where the key vault should be created. Required. :vartype location: str - :ivar tags: A set of tags. The tags that will be assigned to the key vault. + :ivar tags: The tags that will be assigned to the key vault. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the vault. + :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}, + "location": {"required": True}, + "properties": {"required": True}, } _attribute_map = { - 'location': {'key': 'location', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'VaultProperties'}, + "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 + self, *, location: str, properties: "_models.VaultProperties", tags: Optional[Dict[str, str]] = None, **kwargs ): """ - :keyword location: Required. The supported Azure location where the key vault should be - created. + :keyword location: The supported Azure location where the key vault should be created. + Required. :paramtype location: str - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :keyword tags: The tags that will be assigned to the key vault. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultProperties """ - super(VaultCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.location = location self.tags = tags self.properties = properties -class VaultListResult(msrest.serialization.Model): +class VaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of vaults. @@ -2523,40 +2404,34 @@ class VaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Vault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Vault"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(VaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class VaultPatchParameters(msrest.serialization.Model): +class VaultPatchParameters(_serialization.Model): """Parameters for creating or updating a vault. - :ivar tags: A set of tags. The tags that will be assigned to the key 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'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "VaultPatchProperties"}, } def __init__( @@ -2567,17 +2442,17 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :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(VaultPatchParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class VaultPatchProperties(msrest.serialization.Model): +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 @@ -2611,7 +2486,7 @@ class VaultPatchProperties(msrest.serialization.Model): :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", "default". + 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 @@ -2625,18 +2500,18 @@ class VaultPatchProperties(msrest.serialization.Model): """ _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'}, + "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__( @@ -2689,7 +2564,7 @@ def __init__( <=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", "default". + 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 @@ -2701,7 +2576,7 @@ def __init__( specific network locations. :paramtype network_acls: ~azure.mgmt.keyvault.v2020_04_01_preview.models.NetworkRuleSet """ - super(VaultPatchProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies @@ -2716,17 +2591,17 @@ def __init__( self.network_acls = network_acls -class VaultProperties(msrest.serialization.Model): +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 Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :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 @@ -2759,7 +2634,7 @@ class VaultProperties(msrest.serialization.Model): 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", "default". + 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 @@ -2770,7 +2645,7 @@ class VaultProperties(msrest.serialization.Model): :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", + :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 @@ -2781,27 +2656,30 @@ class VaultProperties(msrest.serialization.Model): """ _validation = { - 'tenant_id': {'required': True}, - 'sku': {'required': True}, - 'private_endpoint_connections': {'readonly': True}, + "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]'}, + "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__( @@ -2814,9 +2692,9 @@ def __init__( 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] = True, - soft_delete_retention_in_days: Optional[int] = 90, - enable_rbac_authorization: Optional[bool] = False, + 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, @@ -2824,10 +2702,10 @@ def __init__( **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :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 @@ -2861,7 +2739,7 @@ def __init__( 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", "default". + 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 @@ -2872,12 +2750,12 @@ def __init__( :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", + :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(VaultProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies @@ -2895,13 +2773,14 @@ def __init__( self.private_endpoint_connections = None -class VirtualNetworkRule(msrest.serialization.Model): +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 Azure. - :ivar id: Required. Full resource id of a vnet subnet, such as + :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. @@ -2909,29 +2788,30 @@ class VirtualNetworkRule(msrest.serialization.Model): """ _validation = { - 'id': {'required': True}, + "id": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'ignore_missing_vnet_service_endpoint': {'key': 'ignoreMissingVnetServiceEndpoint', 'type': 'bool'}, + "id": {"key": "id", "type": "str"}, + "ignore_missing_vnet_service_endpoint": {"key": "ignoreMissingVnetServiceEndpoint", "type": "bool"}, } def __init__( self, *, - id: str, + id: str, # pylint: disable=redefined-builtin ignore_missing_vnet_service_endpoint: Optional[bool] = None, **kwargs ): """ - :keyword id: Required. Full resource id of a vnet subnet, such as + :keyword id: Full resource id of a vnet subnet, such as '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. + 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(VirtualNetworkRule, self).__init__(**kwargs) + 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index d8c247e50c9e..7107dc727af4 100644 --- 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 @@ -17,14 +17,15 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'KeysOperations', - 'VaultsOperations', - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'Operations', - 'SecretsOperations', - 'ManagedHsmsOperations', + "KeysOperations", + "VaultsOperations", + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "Operations", + "SecretsOperations", + "ManagedHsmsOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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 index 620d675c95aa..26cb6ff7a1bb 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -20,214 +26,176 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - *, - json: Optional[_models.KeyCreateParameters] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_version_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - key_version: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_versions_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class KeysOperations: """ @@ -248,14 +216,15 @@ def __init__(self, *args, **kwargs): 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") - - @distributed_trace + @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 @@ -263,42 +232,120 @@ def create_if_not_exist( subsequent versions, and does not update existing keys. :param resource_group_name: The name of the resource group which contains the specified key - vault. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. + :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. + :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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_if_not_exist( + self, + resource_group_name: str, + vault_name: str, + key_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a + IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - _json = self._serialize.body(parameters, 'KeyCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "KeyCreateParameters") request = build_create_if_not_exist_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.create_if_not_exist.metadata['url'], + content=_content, + template_url=self.create_if_not_exist.metadata["url"], headers=_headers, params=_params, ) @@ -306,67 +353,61 @@ def create_if_not_exist( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_if_not_exist.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + create_if_not_exist.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> _models.Key: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. + :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. + :param key_name: The name of the key to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -374,65 +415,61 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace - def list( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> Iterable[_models.KeyListResult]: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. + :param vault_name: The name of the vault which contains the keys to be retrieved. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -440,15 +477,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -465,10 +504,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -478,57 +515,53 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore @distributed_trace def get_version( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - key_version: str, - **kwargs: Any + 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. + 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. + :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. + :param key_version: The version of the key to be retrieved. Required. :type key_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_version_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get_version.metadata['url'], + template_url=self.get_version.metadata["url"], headers=_headers, params=_params, ) @@ -536,69 +569,67 @@ def get_version( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_version.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore - + get_version.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore @distributed_trace def list_versions( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> Iterable[_models.KeyListResult]: + 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. + 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. + :param key_name: The name of the key versions to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_versions_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_versions.metadata['url'], + template_url=self.list_versions.metadata["url"], headers=_headers, params=_params, ) @@ -606,16 +637,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_versions_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -632,10 +664,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -645,8 +675,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_versions.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore + list_versions.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore 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 index 45bd72f43730..1c38ca0710a3 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,251 +28,199 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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_initial( - resource_group_name: str, - name: str, - subscription_id: str, - *, - json: Optional[_models.ManagedHsm] = None, - content: Any = None, - **kwargs: Any + +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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) - - -def build_update_request_initial( - resource_group_name: str, - name: str, - subscription_id: str, - *, - json: Optional[_models.ManagedHsm] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) - - -def build_delete_request_initial( - resource_group_name: str, - name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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["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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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'), + "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class ManagedHsmsOperations: """ @@ -287,36 +241,41 @@ def __init__(self, *args, **kwargs): 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") - def _create_or_update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -324,46 +283,87 @@ def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - @distributed_trace + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -375,20 +375,48 @@ def begin_create_or_update( :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 + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def begin_create_or_update( + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **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 model type + or a IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -396,69 +424,71 @@ def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore def _update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_update_request_initial( + 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, - template_url=self._update_initial.metadata['url'], + content=_content, + template_url=self._update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -466,46 +496,87 @@ def _update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - @distributed_trace + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to patch the managed HSM Pool. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -517,20 +588,48 @@ def begin_update( :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 + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def begin_update( + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._update_initial( # type: ignore resource_group_name=resource_group_name, @@ -538,64 +637,59 @@ def begin_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore def _delete_initial( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any + self, resource_group_name: str, name: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_delete_request_initial( + request = build_delete_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -603,34 +697,29 @@ def _delete_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **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) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace - def begin_delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param name: The name of the managed HSM Pool to delete. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -642,92 +731,83 @@ def begin_delete( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore resource_group_name=resource_group_name, name=name, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> Optional[_models.ManagedHsm]: + 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. + :param name: The name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ManagedHsm, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.ManagedHsm]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.ManagedHsm]] - request = build_get_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -735,10 +815,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -748,56 +827,56 @@ def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -805,15 +884,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -830,10 +911,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -844,48 +923,45 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -893,14 +969,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -917,10 +996,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -931,8 +1008,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore 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 index bfc3388e0dce..eda09755bf6c 100644 --- 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 @@ -7,10 +7,16 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +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.pipeline.transport import HttpResponse @@ -20,38 +26,34 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request -T = TypeVar('T') + +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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class Operations: """ @@ -72,36 +74,35 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> Iterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -109,12 +110,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -131,10 +137,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -144,8 +148,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # type: ignore 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index b29fae0a27cb..d883a7234bba 100644 --- 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 @@ -6,11 +6,16 @@ # 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, Callable, Dict, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, 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.pipeline.transport import HttpResponse from azure.core.polling import LROPoller, NoPolling, PollingMethod @@ -21,136 +26,132 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_put_request( - subscription_id: str, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, - *, - json: Optional[_models.PrivateEndpointConnection] = None, - content: Any = None, + subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) -def build_delete_request_initial( - subscription_id: str, +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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateEndpointConnectionsOperations: """ @@ -171,48 +172,45 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def get( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -220,10 +218,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -232,64 +229,140 @@ def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - - @distributed_trace + @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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection or + IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - _json = self._serialize.body(properties, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "PrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -297,10 +370,9 @@ def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -308,45 +380,44 @@ def put( 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')) + 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore def _delete_initial( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -354,10 +425,9 @@ def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -367,37 +437,31 @@ def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def begin_delete( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -411,55 +475,48 @@ def begin_delete( of cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 index 79053ec272c4..4e99369d74b0 100644 --- 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 @@ -8,9 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,48 +24,46 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateLinkResourcesOperations: """ @@ -81,43 +84,41 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def list_by_vault( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateLinkResourceListResult, or the result of cls(response) + :return: PrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.PrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] - request = build_list_by_vault_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_vault.metadata['url'], + template_url=self.list_by_vault.metadata["url"], headers=_headers, params=_params, ) @@ -125,22 +126,20 @@ def list_by_vault( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_vault.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore - + list_by_vault.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # 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 index 1a7823f6be91..a902bd5558f9 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -20,185 +26,150 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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, - *, - json: Optional[_models.SecretCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + 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, - *, - json: Optional[_models.SecretPatchParameters] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class SecretsOperations: """ @@ -219,14 +190,15 @@ def __init__(self, *args, **kwargs): 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") - - @distributed_trace + @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 @@ -234,32 +206,111 @@ def create_or_update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :param secret_name: Name of the secret. Required. :type secret_name: str - :param parameters: Parameters to create or update the secret. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or a IO + type. Required. + :type parameters: + ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -269,7 +320,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -277,10 +329,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -288,26 +339,27 @@ def create_or_update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - @distributed_trace + @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 @@ -315,31 +367,109 @@ def update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :param secret_name: Name of the secret. Required. :type secret_name: str - :param parameters: Parameters to patch the secret. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update( + self, + resource_group_name: str, + vault_name: str, + secret_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -349,7 +479,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -357,10 +488,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -368,60 +498,56 @@ def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - **kwargs: Any - ) -> _models.Secret: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param secret_name: The name of the secret. + :param secret_name: The name of the secret. Required. :type secret_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -429,70 +555,68 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace def list( - self, - resource_group_name: str, - vault_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.SecretListResult]: + 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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SecretListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.SecretListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SecretListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SecretListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, top=top, - template_url=self.list.metadata['url'], + api_version=api_version, + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -500,16 +624,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -526,10 +651,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -539,8 +662,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore 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 index cfabd8b66e13..d2a5d01fde7f 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,485 +28,382 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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_initial( - resource_group_name: str, - vault_name: str, - subscription_id: str, - *, - json: Optional[_models.VaultCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + +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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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, - *, - json: Optional[_models.VaultPatchParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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"], + operation_kind: Union[str, _models.AccessPolicyUpdateKind], subscription_id: str, - *, - json: Optional[_models.VaultAccessPolicyParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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'), + "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_purge_deleted_request_initial( - vault_name: str, - location: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + 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 + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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, *, + filter: Union[str, _models.Enum16], + api_version: Union[str, _models.Enum17], top: Optional[int] = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - filter = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - accept = _headers.pop('Accept', "application/json") + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') + _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') + _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 - ) + _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, - *, - json: Optional[_models.VaultCheckNameAvailabilityParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability") + _url = kwargs.pop( + "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability" + ) path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: """ @@ -521,36 +424,45 @@ def __init__(self, *args, **kwargs): 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") - def _create_or_update_initial( self, resource_group_name: str, vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **kwargs: Any ) -> _models.Vault: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -558,10 +470,9 @@ def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -569,35 +480,110 @@ def _create_or_update_initial( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :param parameters: Parameters to create or update the vault. Is either a model type or a IO + type. Required. :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultCreateOrUpdateParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -608,20 +594,17 @@ def begin_create_or_update( Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -629,74 +612,140 @@ def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -705,7 +754,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -713,10 +763,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -724,55 +773,54 @@ def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -780,10 +828,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -793,45 +840,42 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -839,64 +883,144 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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: _models.VaultAccessPolicyParameters, + operation_kind: Union[str, _models.AccessPolicyUpdateKind], + parameters: Union[_models.VaultAccessPolicyParameters, IO], **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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :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. + :param parameters: Access policy to merge into the vault. Is either a model type or a IO type. + Required. :type parameters: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -906,7 +1030,8 @@ def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -914,10 +1039,9 @@ def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -925,58 +1049,58 @@ def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -984,15 +1108,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1009,10 +1135,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1022,46 +1146,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -1069,14 +1190,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1093,10 +1217,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1106,43 +1228,41 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> Iterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) + :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.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1150,13 +1270,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1173,10 +1297,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1186,48 +1308,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace - def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1235,50 +1352,47 @@ def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -1286,10 +1400,9 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -1299,21 +1412,15 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace - def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -1325,99 +1432,93 @@ def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace def list( self, + filter: Union[str, _models.Enum16], + api_version: Union[str, _models.Enum17], top: Optional[int] = None, **kwargs: Any - ) -> Iterable[_models.ResourceListResult]: + ) -> Iterable["_models.Resource"]: """The List operation gets information about the vaults associated with the subscription. + :param filter: The filter to apply on the operation. "resourceType eq + 'Microsoft.KeyVault/vaults'" Required. + :type filter: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.Enum16 + :param api_version: Azure Resource Manager Api Version. "2015-11-01" Required. + :type api_version: str or ~azure.mgmt.keyvault.v2020_04_01_preview.models.Enum17 :param top: Maximum number of results to return. Default value is None. :type top: int - :keyword filter: The filter to apply on the operation. Default value is "resourceType eq - 'Microsoft.KeyVault/vaults'". Note that overriding this default value may result in unsupported - behavior. - :paramtype filter: str - :keyword api_version: Azure Resource Manager Api Version. Default value is "2015-11-01". Note - that overriding this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2020_04_01_preview.models.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 {}) + _params = kwargs.pop("params", {}) or {} - filter = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, filter=filter, api_version=api_version, top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -1425,15 +1526,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1450,10 +1553,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1463,48 +1564,96 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace + @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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2020_04_01_preview.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def check_name_availability( + self, vault_name: IO, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], **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 model type or a IO type. Required. + :type vault_name: + ~azure.mgmt.keyvault.v2020_04_01_preview.models.VaultCheckNameAvailabilityParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2020-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1512,22 +1661,20 @@ def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore 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 index d19915ab3650..731fc6d4be82 100644 --- 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 @@ -17,7 +17,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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 index 4d4603815fb9..b19cec2eed15 100644 --- 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 @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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: + def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2021-04-01-preview") # type: str + api_version = kwargs.pop("api_version", "2021-04-01-preview") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,23 +47,24 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) self._configure(**kwargs) def _configure( - self, - **kwargs # type: Any + self, **kwargs # type: Any ): # type: (...) -> 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.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs) + 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) + 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 index fe22de668716..03cf4a3197ae 100644 --- 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 @@ -9,20 +9,28 @@ from copy import deepcopy from typing import Any, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import HttpRequest, HttpResponse from azure.mgmt.core import ARMPipelineClient from . import models +from .._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration -from .operations import MHSMPrivateEndpointConnectionsOperations, MHSMPrivateLinkResourcesOperations, ManagedHsmsOperations, Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, VaultsOperations +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=too-many-instance-attributes + +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. @@ -44,10 +52,10 @@ class KeyVaultManagementClient: # pylint: disable=too-many-instance-attribute 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. + :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. + 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 @@ -65,41 +73,32 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = ARMPipelineClient(base_url=base_url, config=self._config, **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 - ) + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) self.private_endpoint_connections = PrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.managed_hsms = ManagedHsmsOperations(self._client, self._config, self._serialize, self._deserialize) self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) - - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> HttpResponse: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -108,7 +107,7 @@ def _send_request( >>> response = client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 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 index df98e14ba570..9afd4e22441c 100644 --- 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 @@ -10,20 +10,20 @@ "azure_arm": true, "has_lro_operations": true, "client_side_validation": false, - "sync_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"ARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}", - "async_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"], \"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"AsyncARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}" + "sync_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"ARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \".._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", + "async_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"AsyncARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \"..._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" }, "global_parameters": { "sync": { "credential": { - "signature": "credential, # type: \"TokenCredential\"", - "description": "Credential needed for the client to connect to Azure.", + "signature": "credential: \"TokenCredential\",", + "description": "Credential needed for the client to connect to Azure. Required.", "docstring_type": "~azure.core.credentials.TokenCredential", "required": true }, "subscription_id": { - "signature": "subscription_id, # type: str", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.", + "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 } @@ -31,13 +31,13 @@ "async": { "credential": { "signature": "credential: \"AsyncTokenCredential\",", - "description": "Credential needed for the client to connect to Azure.", + "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.", + "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 } @@ -54,7 +54,7 @@ "required": false }, "base_url": { - "signature": "base_url=\"https://management.azure.com\", # type: str", + "signature": "base_url: str = \"https://management.azure.com\",", "description": "Service URL", "docstring_type": "str", "required": false 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 index 74e48ecd07cf..f99e77fef986 100644 --- 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 @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_vendor.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_vendor.py index 138f663c53a4..9aad73fc743e 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_vendor.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_04_01_preview/_vendor.py @@ -7,6 +7,7 @@ from azure.core.pipeline.transport import HttpRequest + def _convert_request(request, files=None): data = request.content if not files else None request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) @@ -14,6 +15,7 @@ def _convert_request(request, files=None): request.set_formdata_body(files) return request + def _format_url_section(template, **kwargs): components = template.split("/") while components: @@ -21,7 +23,5 @@ def _format_url_section(template, **kwargs): return template.format(**kwargs) except KeyError as key: formatted_components = template.split("/") - components = [ - c for c in formatted_components if "{}".format(key.args[0]) not in c - ] + components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] template = "/".join(components) 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 index c1257f7f4e11..e5754a47ce68 100644 --- 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 @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "10.1.0" +VERSION = "1.0.0b1" 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 index 1aa2a0b291a3..c2c64fd1638f 100644 --- 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 @@ -14,7 +14,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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 index 4e1fdad69e61..cf2e7b634307 100644 --- 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 @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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: + def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2021-04-01-preview") # type: str + api_version = kwargs.pop("api_version", "2021-04-01-preview") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,22 +47,21 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) 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.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) + 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) + 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 index 88b5f2ea8cb0..bfa3fdb4d58d 100644 --- 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 @@ -9,20 +9,28 @@ from copy import deepcopy from typing import Any, Awaitable, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.mgmt.core import AsyncARMPipelineClient from .. import models +from ..._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration -from .operations import MHSMPrivateEndpointConnectionsOperations, MHSMPrivateLinkResourcesOperations, ManagedHsmsOperations, Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, VaultsOperations +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=too-many-instance-attributes + +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. @@ -45,10 +53,10 @@ class KeyVaultManagementClient: # pylint: disable=too-many-instance-attribute 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. + :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. + 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 @@ -66,41 +74,32 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **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 - ) + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) self.private_endpoint_connections = PrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.managed_hsms = ManagedHsmsOperations(self._client, self._config, self._serialize, self._deserialize) self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) - - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -109,7 +108,7 @@ def _send_request( >>> response = await client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 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 index 74e48ecd07cf..f99e77fef986 100644 --- 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 @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass 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 index 1ab91d2ad823..6acb1b876c98 100644 --- 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 @@ -17,14 +17,15 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'VaultsOperations', - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'ManagedHsmsOperations', - 'MHSMPrivateEndpointConnectionsOperations', - 'MHSMPrivateLinkResourcesOperations', - 'Operations', + "VaultsOperations", + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "ManagedHsmsOperations", + "MHSMPrivateEndpointConnectionsOperations", + "MHSMPrivateLinkResourcesOperations", + "Operations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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 index 9e0e1a22361f..cf0e8473436a 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,22 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._managed_hsms_operations import build_create_or_update_request_initial, build_delete_request_initial, 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_initial, build_update_request_initial -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class ManagedHsmsOperations: """ .. warning:: @@ -45,36 +65,41 @@ def __init__(self, *args, **kwargs) -> None: 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") - async def _create_or_update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -82,46 +107,120 @@ async def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - @distributed_trace_async + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], **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 model type + or a IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -134,20 +233,17 @@ async def begin_create_or_update( cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -155,69 +251,71 @@ async def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore async def _update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_update_request_initial( + 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, - template_url=self._update_initial.metadata['url'], + content=_content, + template_url=self._update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -225,49 +323,54 @@ async def _update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + 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 = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - - deserialized = self._deserialize('ManagedHsm', pipeline_response) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + _update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - - @distributed_trace_async + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to patch the managed HSM Pool. + :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 :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -280,20 +383,86 @@ async def begin_update( cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def begin_update( + self, + resource_group_name: str, + name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._update_initial( # type: ignore resource_group_name=resource_group_name, @@ -301,64 +470,59 @@ async def begin_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore async def _delete_initial( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any + self, resource_group_name: str, name: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_delete_request_initial( + request = build_delete_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -366,34 +530,29 @@ async def _delete_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **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) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace_async - async def begin_delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param name: The name of the managed HSM Pool to delete. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -405,92 +564,83 @@ async def begin_delete( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore resource_group_name=resource_group_name, name=name, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> Optional[_models.ManagedHsm]: + 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. + :param name: The name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ManagedHsm, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.ManagedHsm]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.ManagedHsm]] - request = build_get_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -498,10 +648,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -511,56 +660,56 @@ async def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -568,15 +717,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -593,10 +744,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -607,48 +756,45 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -656,14 +802,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -680,10 +829,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -694,44 +841,42 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> AsyncIterable[_models.DeletedManagedHsmListResult]: + def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedManagedHsm"]: """The List operation gets information about the deleted managed HSMs associated with the subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedManagedHsmListResult or the result of - cls(response) + :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.DeletedManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -739,13 +884,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -762,10 +911,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -776,48 +923,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore @distributed_trace_async - async def get_deleted( - self, - name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedManagedHsm: + 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. + :param name: The name of the deleted managed HSM. Required. :type name: str - :param location: The location of the deleted managed HSM. + :param location: The location of the deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedManagedHsm, or the result of cls(response) + :return: DeletedManagedHsm or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedManagedHsm - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsm] - request = build_get_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -825,10 +967,9 @@ async def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -836,40 +977,38 @@ async def get_deleted( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DeletedManagedHsm', pipeline_response) + deserialized = self._deserialize("DeletedManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore async def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any + self, name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -877,34 +1016,28 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore @distributed_trace_async - async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param name: The name of the soft-deleted managed HSM. Required. :type name: str - :param location: The location of the soft-deleted managed HSM. + :param location: The location of the soft-deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -916,52 +1049,45 @@ async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._purge_deleted_initial( # type: ignore name=name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # 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 index 1b5e0a92b554..4bccedd04a70 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,17 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._mhsm_private_endpoint_connections_operations import build_delete_request_initial, build_get_request, build_list_by_resource_request, build_put_request -T = TypeVar('T') +from ...operations._mhsm_private_endpoint_connections_operations import ( + build_delete_request, + build_get_request, + build_list_by_resource_request, + build_put_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class MHSMPrivateEndpointConnectionsOperations: """ .. warning:: @@ -45,47 +60,48 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace def list_by_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> AsyncIterable[_models.MHSMPrivateEndpointConnectionsListResult]: + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either MHSMPrivateEndpointConnectionsListResult or the - result of cls(response) + :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.MHSMPrivateEndpointConnectionsListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -93,15 +109,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -118,10 +136,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -132,53 +148,50 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -186,10 +199,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -197,15 +209,78 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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( @@ -213,48 +288,64 @@ async def put( resource_group_name: str, name: str, private_endpoint_connection_name: str, - properties: _models.MHSMPrivateEndpointConnection, + properties: Union[_models.MHSMPrivateEndpointConnection, IO], **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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :param properties: The intended state of private endpoint connection. Is either a model type or + a IO type. Required. :type properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - _json = self._serialize.body(properties, 'MHSMPrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -262,10 +353,9 @@ async def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -273,45 +363,44 @@ async def put( 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')) + 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) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore async def _delete_initial( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.MHSMPrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -319,10 +408,9 @@ async def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -332,37 +420,32 @@ async def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace_async async def begin_delete( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -376,55 +459,48 @@ async def begin_delete( result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 index dd930eae9d4f..6e3704b61287 100644 --- 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 @@ -8,7 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -19,9 +26,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._mhsm_private_link_resources_operations import build_list_by_mhsm_resource_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class MHSMPrivateLinkResourcesOperations: """ .. warning:: @@ -41,43 +50,42 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def list_by_mhsm_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateLinkResourceListResult, or the result of cls(response) + :return: MHSMPrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] - request = build_list_by_mhsm_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_mhsm_resource.metadata['url'], + template_url=self.list_by_mhsm_resource.metadata["url"], headers=_headers, params=_params, ) @@ -85,22 +93,20 @@ async def list_by_mhsm_resource( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_mhsm_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # type: ignore - + list_by_mhsm_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # 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 index 52104e00ff3e..9b03fd8597af 100644 --- 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 @@ -7,9 +7,17 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,9 +28,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._operations import build_list_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class Operations: """ .. warning:: @@ -42,36 +52,36 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> AsyncIterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) + :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.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -79,12 +89,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -101,10 +116,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -114,8 +127,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # type: ignore 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index d23e84cd1c75..558aadaf415d 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,17 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._private_endpoint_connections_operations import build_delete_request_initial, build_get_request, build_list_by_resource_request, build_put_request -T = TypeVar('T') +from ...operations._private_endpoint_connections_operations import ( + build_delete_request, + build_get_request, + build_list_by_resource_request, + build_put_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateEndpointConnectionsOperations: """ .. warning:: @@ -45,48 +60,45 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def get( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -94,10 +106,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -106,64 +117,140 @@ async def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - @distributed_trace_async + @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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection or + IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - _json = self._serialize.body(properties, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "PrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -171,10 +258,9 @@ async def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -182,45 +268,44 @@ async def put( 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')) + 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore async def _delete_initial( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -228,10 +313,9 @@ async def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -241,37 +325,31 @@ async def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace_async async def begin_delete( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -285,99 +363,93 @@ async def begin_delete( result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def list_by_resource( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.PrivateEndpointConnectionListResult]: + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either PrivateEndpointConnectionListResult or the result - of cls(response) + :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.PrivateEndpointConnectionListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnectionListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -385,15 +457,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -410,10 +484,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -423,8 +495,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore 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 index 1e31dc77d60c..edd34cc4dcd8 100644 --- 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 @@ -8,7 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -19,9 +26,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._private_link_resources_operations import build_list_by_vault_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateLinkResourcesOperations: """ .. warning:: @@ -41,43 +50,41 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def list_by_vault( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateLinkResourceListResult, or the result of cls(response) + :return: PrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] - request = build_list_by_vault_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_vault.metadata['url'], + template_url=self.list_by_vault.metadata["url"], headers=_headers, params=_params, ) @@ -85,22 +92,20 @@ async def list_by_vault( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_vault.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore - + list_by_vault.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # 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 index 0c3a0fbf8bd8..46f8f73acafd 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,25 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._vaults_operations import build_check_name_availability_request, build_create_or_update_request_initial, 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_initial, build_update_access_policy_request, build_update_request -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class VaultsOperations: """ .. warning:: @@ -45,36 +68,45 @@ def __init__(self, *args, **kwargs) -> None: 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") - async def _create_or_update_initial( self, resource_group_name: str, vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **kwargs: Any ) -> _models.Vault: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -82,10 +114,9 @@ async def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -93,35 +124,112 @@ async def _create_or_update_initial( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :param parameters: Parameters to create or update the vault. Is either a model type or a IO + type. Required. :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultCreateOrUpdateParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -133,20 +241,17 @@ async def begin_create_or_update( :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -154,74 +259,140 @@ async def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace_async + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update( + self, + resource_group_name: str, + vault_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -230,7 +401,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -238,10 +410,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -249,55 +420,54 @@ async def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -305,10 +475,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -318,45 +487,42 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -364,64 +530,144 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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: _models.VaultAccessPolicyParameters, + operation_kind: Union[str, _models.AccessPolicyUpdateKind], + parameters: Union[_models.VaultAccessPolicyParameters, IO], **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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :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. + :param parameters: Access policy to merge into the vault. Is either a model type or a IO type. + Required. :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -431,7 +677,8 @@ async def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -439,10 +686,9 @@ async def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -450,58 +696,59 @@ async def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) + :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.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -509,15 +756,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -534,10 +783,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -547,46 +794,44 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) + :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.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -594,14 +839,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -618,10 +866,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -631,43 +877,41 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> AsyncIterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) + :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.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -675,13 +919,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -698,10 +946,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -711,48 +957,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace_async - async def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -760,50 +1001,47 @@ async def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore async def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -811,10 +1049,9 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -824,21 +1061,15 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace_async - async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -850,99 +1081,94 @@ async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace def list( self, + filter: Union[str, _models.Enum12], + api_version: Union[str, _models.Enum13], top: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable[_models.ResourceListResult]: + ) -> AsyncIterable["_models.Resource"]: """The List operation gets information about the vaults associated with the subscription. + :param filter: The filter to apply on the operation. "resourceType eq + 'Microsoft.KeyVault/vaults'" Required. + :type filter: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.Enum12 + :param api_version: Azure Resource Manager Api Version. "2015-11-01" Required. + :type api_version: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.Enum13 :param top: Maximum number of results to return. Default value is None. :type top: int - :keyword filter: The filter to apply on the operation. Default value is "resourceType eq - 'Microsoft.KeyVault/vaults'". Note that overriding this default value may result in unsupported - behavior. - :paramtype filter: str - :keyword api_version: Azure Resource Manager Api Version. Default value is "2015-11-01". Note - that overriding this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) + :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.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 {}) + _params = kwargs.pop("params", {}) or {} - filter = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, filter=filter, api_version=api_version, top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -950,15 +1176,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -975,10 +1203,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -988,48 +1214,96 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace_async + @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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def check_name_availability( + self, vault_name: IO, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], **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 model type or a IO type. Required. + :type vault_name: + ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultCheckNameAvailabilityParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1037,22 +1311,20 @@ async def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # 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 index f26a52d26fd7..dd53acbe1b12 100644 --- 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 @@ -64,110 +64,112 @@ from ._models_py3 import VaultProperties from ._models_py3 import VirtualNetworkRule - -from ._key_vault_management_client_enums import ( - AccessPolicyUpdateKind, - ActionsRequired, - CertificatePermissions, - CreateMode, - IdentityType, - KeyPermissions, - ManagedHsmSkuFamily, - ManagedHsmSkuName, - NetworkRuleAction, - NetworkRuleBypassOptions, - PrivateEndpointConnectionProvisioningState, - PrivateEndpointServiceConnectionStatus, - ProvisioningState, - PublicNetworkAccess, - Reason, - SecretPermissions, - SkuFamily, - SkuName, - StoragePermissions, - VaultProvisioningState, -) +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 Enum12 +from ._key_vault_management_client_enums import Enum13 +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 * # type: ignore # 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', + "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", + "Enum12", + "Enum13", + "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() \ No newline at end of file +_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 index 9be18cf6d969..8f9f803dc279 100644 --- 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 @@ -11,24 +11,27 @@ 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. - """ + """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_ENUM = "import" + IMPORT = "import" UPDATE = "update" MANAGECONTACTS = "managecontacts" GETISSUERS = "getissuers" @@ -41,23 +44,37 @@ class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): BACKUP = "backup" RESTORE = "restore" + class CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The vault's create mode to indicate whether the vault need to be recovered or not. - """ + """The vault's create mode to indicate whether the vault need to be recovered or not.""" RECOVER = "recover" DEFAULT = "default" + +class Enum12(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Enum12.""" + + RESOURCE_TYPE_EQ_MICROSOFT_KEY_VAULT_VAULTS_ = "resourceType eq 'Microsoft.KeyVault/vaults'" + + +class Enum13(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Enum13.""" + + TWO_THOUSAND_FIFTEEN11_01 = "2015-11-01" + + class IdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of identity. - """ + """The type of identity.""" USER = "User" APPLICATION = "Application" MANAGED_IDENTITY = "ManagedIdentity" KEY = "Key" + class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """KeyPermissions.""" ENCRYPT = "encrypt" DECRYPT = "decrypt" @@ -69,7 +86,7 @@ class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): LIST = "list" CREATE = "create" UPDATE = "update" - IMPORT_ENUM = "import" + IMPORT = "import" DELETE = "delete" BACKUP = "backup" RESTORE = "restore" @@ -77,19 +94,20 @@ class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): PURGE = "purge" RELEASE = "release" + class ManagedHsmSkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU Family of the managed HSM Pool - """ + """SKU Family of the managed HSM Pool.""" B = "B" + class ManagedHsmSkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU of the managed HSM Pool - """ + """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. @@ -98,6 +116,7 @@ class NetworkRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta): 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'. @@ -106,9 +125,9 @@ class NetworkRuleBypassOptions(str, Enum, metaclass=CaseInsensitiveEnumMeta): AZURE_SERVICES = "AzureServices" NONE = "None" + class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The current provisioning state. - """ + """The current provisioning state.""" SUCCEEDED = "Succeeded" CREATING = "Creating" @@ -117,18 +136,18 @@ class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsens FAILED = "Failed" DISCONNECTED = "Disconnected" + class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The private endpoint connection status. - """ + """The private endpoint connection status.""" PENDING = "Pending" APPROVED = "Approved" REJECTED = "Rejected" DISCONNECTED = "Disconnected" + class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state. - """ + """Provisioning state.""" #: The managed HSM Pool has been full provisioned. SUCCEEDED = "Succeeded" @@ -147,6 +166,7 @@ class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): #: The managed HSM pool is being restored from full HSM backup. RESTORING = "Restoring" + class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Control permission for data plane traffic coming from public networks while private endpoint is enabled. @@ -155,6 +175,7 @@ class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta): 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. @@ -163,7 +184,9 @@ class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta): ACCOUNT_NAME_INVALID = "AccountNameInvalid" ALREADY_EXISTS = "AlreadyExists" + class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """SecretPermissions.""" GET = "get" LIST = "list" @@ -174,20 +197,22 @@ class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): RECOVER = "recover" PURGE = "purge" + class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU family name - """ + """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. - """ + """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" @@ -204,9 +229,9 @@ class StoragePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): GETSAS = "getsas" DELETESAS = "deletesas" + class VaultProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state of the vault. - """ + """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 index 6b21cdcf6043..f38268dc2b86 100644 --- 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 @@ -1,4 +1,5 @@ # 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. @@ -9,43 +10,42 @@ import datetime from typing import Dict, List, Optional, TYPE_CHECKING, Union -from azure.core.exceptions import HttpResponseError -import msrest.serialization +from ... import _serialization if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - import __init__ as _models + from .. import models as _models -class AccessPolicyEntry(msrest.serialization.Model): +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 Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and certificates. + :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}, + "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'}, + "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__( @@ -58,27 +58,27 @@ def __init__( **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and - certificates. + :keyword permissions: Permissions the identity has for keys, secrets and certificates. + Required. :paramtype permissions: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Permissions """ - super(AccessPolicyEntry, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.object_id = object_id self.application_id = application_id self.permissions = permissions -class CheckNameAvailabilityResult(msrest.serialization.Model): +class CheckNameAvailabilityResult(_serialization.Model): """The CheckNameAvailability operation response. Variables are only populated by the server, and will be ignored when sending a request. @@ -88,37 +88,33 @@ class CheckNameAvailabilityResult(msrest.serialization.Model): 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", "AlreadyExists". + 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}, + "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'}, + "name_available": {"key": "nameAvailable", "type": "bool"}, + "reason": {"key": "reason", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(CheckNameAvailabilityResult, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.name_available = None self.reason = None self.message = None -class CloudErrorBody(msrest.serialization.Model): +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. @@ -129,17 +125,11 @@ class CloudErrorBody(msrest.serialization.Model): """ _attribute_map = { - 'code': {'key': 'code', 'type': 'str'}, - 'message': {'key': 'message', 'type': 'str'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - *, - code: Optional[str] = None, - message: Optional[str] = None, - **kwargs - ): + def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs): """ :keyword code: Error code. This is a mnemonic that can be consumed programmatically. :paramtype code: str @@ -147,12 +137,12 @@ def __init__( with service version. :paramtype message: str """ - super(CloudErrorBody, self).__init__(**kwargs) + super().__init__(**kwargs) self.code = code self.message = message -class DeletedManagedHsm(msrest.serialization.Model): +class DeletedManagedHsm(_serialization.Model): """DeletedManagedHsm. Variables are only populated by the server, and will be ignored when sending a request. @@ -169,37 +159,32 @@ class DeletedManagedHsm(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "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'}, + "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 - ): + def __init__(self, *, properties: Optional["_models.DeletedManagedHsmProperties"] = None, **kwargs): """ :keyword properties: Properties of the deleted managed HSM. :paramtype properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedManagedHsmProperties """ - super(DeletedManagedHsm, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None self.properties = properties -class DeletedManagedHsmListResult(msrest.serialization.Model): +class DeletedManagedHsmListResult(_serialization.Model): """List of deleted managed HSM Pools. :ivar value: The list of deleted managed HSM Pools. @@ -209,16 +194,12 @@ class DeletedManagedHsmListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DeletedManagedHsm]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.DeletedManagedHsm"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of deleted managed HSM Pools. @@ -226,12 +207,12 @@ def __init__( :keyword next_link: The URL to get the next set of deleted managed HSM Pools. :paramtype next_link: str """ - super(DeletedManagedHsmListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class DeletedManagedHsmProperties(msrest.serialization.Model): +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. @@ -246,35 +227,31 @@ class DeletedManagedHsmProperties(msrest.serialization.Model): :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: A set of tags. Tags of the original managed HSM. + :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}, + "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}'}, + "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 - ): - """ - """ - super(DeletedManagedHsmProperties, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.mhsm_id = None self.location = None self.deletion_date = None @@ -283,7 +260,7 @@ def __init__( self.tags = None -class DeletedVault(msrest.serialization.Model): +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. @@ -299,36 +276,31 @@ class DeletedVault(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "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'}, + "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 - ): + def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs): """ :keyword properties: Properties of the vault. :paramtype properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedVaultProperties """ - super(DeletedVault, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None self.properties = properties -class DeletedVaultListResult(msrest.serialization.Model): +class DeletedVaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of deleted vaults. @@ -338,16 +310,12 @@ class DeletedVaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DeletedVault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.DeletedVault"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of deleted vaults. @@ -355,12 +323,12 @@ def __init__( :keyword next_link: The URL to get the next set of deleted vaults. :paramtype next_link: str """ - super(DeletedVaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class DeletedVaultProperties(msrest.serialization.Model): +class DeletedVaultProperties(_serialization.Model): """Properties of the deleted vault. Variables are only populated by the server, and will be ignored when sending a request. @@ -373,37 +341,33 @@ class DeletedVaultProperties(msrest.serialization.Model): :vartype deletion_date: ~datetime.datetime :ivar scheduled_purge_date: The scheduled purged date. :vartype scheduled_purge_date: ~datetime.datetime - :ivar tags: A set of tags. Tags of the original vault. + :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}, + "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'}, + "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 - ): - """ - """ - super(DeletedVaultProperties, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.vault_id = None self.location = None self.deletion_date = None @@ -412,7 +376,7 @@ def __init__( self.purge_protection_enabled = None -class DimensionProperties(msrest.serialization.Model): +class DimensionProperties(_serialization.Model): """Type of operation: get, read, delete, etc. :ivar name: Name of dimension. @@ -425,9 +389,9 @@ class DimensionProperties(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'to_be_exported_for_shoebox': {'key': 'toBeExportedForShoebox', 'type': 'bool'}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "to_be_exported_for_shoebox": {"key": "toBeExportedForShoebox", "type": "bool"}, } def __init__( @@ -447,13 +411,13 @@ def __init__( exported for Shoebox. :paramtype to_be_exported_for_shoebox: bool """ - super(DimensionProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.to_be_exported_for_shoebox = to_be_exported_for_shoebox -class Error(msrest.serialization.Model): +class Error(_serialization.Model): """The server error. Variables are only populated by the server, and will be ignored when sending a request. @@ -467,63 +431,54 @@ class Error(msrest.serialization.Model): """ _validation = { - 'code': {'readonly': True}, - 'message': {'readonly': True}, - 'inner_error': {'readonly': True}, + "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'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, + "inner_error": {"key": "innererror", "type": "Error"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(Error, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.code = None self.message = None self.inner_error = None -class IPRule(msrest.serialization.Model): +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 Azure. - :ivar value: Required. 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). + :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}, + "value": {"required": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, + "value": {"key": "value", "type": "str"}, } - def __init__( - self, - *, - value: str, - **kwargs - ): + def __init__(self, *, value: str, **kwargs): """ - :keyword value: Required. 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). + :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(IPRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class LogSpecification(msrest.serialization.Model): +class LogSpecification(_serialization.Model): """Log specification of operation. :ivar name: Name of log specification. @@ -535,9 +490,9 @@ class LogSpecification(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'blob_duration': {'key': 'blobDuration', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "blob_duration": {"key": "blobDuration", "type": "str"}, } def __init__( @@ -556,13 +511,13 @@ def __init__( :keyword blob_duration: Blob duration of specification. :paramtype blob_duration: str """ - super(LogSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.blob_duration = blob_duration -class ManagedHsmResource(msrest.serialization.Model): +class ManagedHsmResource(_serialization.Model): """Managed HSM resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -577,7 +532,7 @@ class ManagedHsmResource(msrest.serialization.Model): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -585,20 +540,20 @@ class ManagedHsmResource(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'system_data': {'readonly': True}, + "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'}, + "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__( @@ -614,10 +569,10 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :keyword tags: Resource tags. :paramtype tags: dict[str, str] """ - super(ManagedHsmResource, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -642,7 +597,7 @@ class ManagedHsm(ManagedHsmResource): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -652,21 +607,21 @@ class ManagedHsm(ManagedHsmResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'system_data': {'readonly': True}, + "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'}, + "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__( @@ -683,16 +638,16 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :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(ManagedHsm, self).__init__(location=location, sku=sku, tags=tags, **kwargs) + super().__init__(location=location, sku=sku, tags=tags, **kwargs) self.properties = properties -class ManagedHsmError(msrest.serialization.Model): +class ManagedHsmError(_serialization.Model): """The error exception. Variables are only populated by the server, and will be ignored when sending a request. @@ -702,24 +657,20 @@ class ManagedHsmError(msrest.serialization.Model): """ _validation = { - 'error': {'readonly': True}, + "error": {"readonly": True}, } _attribute_map = { - 'error': {'key': 'error', 'type': 'Error'}, + "error": {"key": "error", "type": "Error"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(ManagedHsmError, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.error = None -class ManagedHsmListResult(msrest.serialization.Model): +class ManagedHsmListResult(_serialization.Model): """List of managed HSM Pools. :ivar value: The list of managed HSM Pools. @@ -729,16 +680,12 @@ class ManagedHsmListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[ManagedHsm]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.ManagedHsm"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of managed HSM Pools. @@ -746,12 +693,12 @@ def __init__( :keyword next_link: The URL to get the next set of managed HSM Pools. :paramtype next_link: str """ - super(ManagedHsmListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class ManagedHsmProperties(msrest.serialization.Model): +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. @@ -778,12 +725,12 @@ class ManagedHsmProperties(msrest.serialization.Model): 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", "default". + 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", "Restoring". + "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 @@ -794,7 +741,7 @@ class ManagedHsmProperties(msrest.serialization.Model): :vartype private_endpoint_connections: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnectionItem] :ivar public_network_access: Control permission for data plane traffic coming from public - networks while private endpoint is enabled. Known values are: "Enabled", "Disabled". + networks while private endpoint is enabled. 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. @@ -802,27 +749,30 @@ class ManagedHsmProperties(msrest.serialization.Model): """ _validation = { - 'hsm_uri': {'readonly': True}, - 'status_message': {'readonly': True}, - 'provisioning_state': {'readonly': True}, - 'private_endpoint_connections': {'readonly': True}, - 'scheduled_purge_date': {'readonly': True}, + "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'}, + "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__( @@ -830,9 +780,9 @@ def __init__( *, tenant_id: Optional[str] = None, initial_admin_object_ids: Optional[List[str]] = None, - enable_soft_delete: Optional[bool] = True, - soft_delete_retention_in_days: Optional[int] = 90, - enable_purge_protection: Optional[bool] = True, + 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: Optional[Union[str, "_models.PublicNetworkAccess"]] = None, @@ -860,17 +810,17 @@ def __init__( 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", "default". + 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 for data plane traffic coming from public - networks while private endpoint is enabled. Known values are: "Enabled", "Disabled". + networks while private endpoint is enabled. Known values are: "Enabled" and "Disabled". :paramtype public_network_access: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.PublicNetworkAccess """ - super(ManagedHsmProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.initial_admin_object_ids = initial_admin_object_ids self.hsm_uri = None @@ -886,48 +836,48 @@ def __init__( self.scheduled_purge_date = None -class ManagedHsmSku(msrest.serialization.Model): +class ManagedHsmSku(_serialization.Model): """SKU details. All required parameters must be populated in order to send to Azure. - :ivar family: Required. SKU Family of the managed HSM Pool. Known values are: "B". + :ivar family: SKU Family of the managed HSM Pool. Required. "B" :vartype family: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSkuFamily - :ivar name: Required. SKU of the managed HSM Pool. Known values are: "Standard_B1", + :ivar name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1" and "Custom_B32". :vartype name: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSkuName """ _validation = { - 'family': {'required': True}, - 'name': {'required': True}, + "family": {"required": True}, + "name": {"required": True}, } _attribute_map = { - 'family': {'key': 'family', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, + "family": {"key": "family", "type": "str"}, + "name": {"key": "name", "type": "str"}, } def __init__( self, *, - family: Union[str, "_models.ManagedHsmSkuFamily"] = "B", + family: Union[str, "_models.ManagedHsmSkuFamily"], name: Union[str, "_models.ManagedHsmSkuName"], **kwargs ): """ - :keyword family: Required. SKU Family of the managed HSM Pool. Known values are: "B". + :keyword family: SKU Family of the managed HSM Pool. Required. "B" :paramtype family: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSkuFamily - :keyword name: Required. SKU of the managed HSM Pool. Known values are: "Standard_B1", + :keyword name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1" and "Custom_B32". :paramtype name: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSkuName """ - super(ManagedHsmSku, self).__init__(**kwargs) + super().__init__(**kwargs) self.family = family self.name = name -class MetricSpecification(msrest.serialization.Model): +class MetricSpecification(_serialization.Model): # pylint: disable=too-many-instance-attributes """Metric specification of operation. :ivar name: Name of metric specification. @@ -956,17 +906,17 @@ class MetricSpecification(msrest.serialization.Model): """ _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'}, + "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__( @@ -1011,7 +961,7 @@ def __init__( :keyword internal_metric_name: The internal metric name. :paramtype internal_metric_name: str """ - super(MetricSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.display_description = display_description @@ -1025,50 +975,45 @@ def __init__( self.internal_metric_name = internal_metric_name -class MHSMIPRule(msrest.serialization.Model): +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 Azure. - :ivar value: Required. 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). + :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}, + "value": {"required": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, + "value": {"key": "value", "type": "str"}, } - def __init__( - self, - *, - value: str, - **kwargs - ): + def __init__(self, *, value: str, **kwargs): """ - :keyword value: Required. 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). + :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(MHSMIPRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class MHSMNetworkRuleSet(msrest.serialization.Model): +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", + '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", "Deny". + "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. @@ -1079,10 +1024,10 @@ class MHSMNetworkRuleSet(msrest.serialization.Model): """ _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]'}, + "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__( @@ -1096,13 +1041,13 @@ 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", + '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", "Deny". + 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. @@ -1111,14 +1056,14 @@ def __init__( :paramtype virtual_network_rules: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMVirtualNetworkRule] """ - super(MHSMNetworkRuleSet, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class MHSMPrivateEndpoint(_serialization.Model): """Private endpoint object properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -1128,24 +1073,20 @@ class MHSMPrivateEndpoint(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, + "id": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(MHSMPrivateEndpoint, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None -class MHSMPrivateEndpointConnection(ManagedHsmResource): +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. @@ -1160,7 +1101,7 @@ class MHSMPrivateEndpointConnection(ManagedHsmResource): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -1173,30 +1114,33 @@ class MHSMPrivateEndpointConnection(ManagedHsmResource): :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", "Disconnected". + 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}, + "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'}, + "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__( @@ -1216,7 +1160,7 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :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 @@ -1227,18 +1171,18 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnectionProvisioningState """ - super(MHSMPrivateEndpointConnection, self).__init__(location=location, sku=sku, tags=tags, **kwargs) + 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(msrest.serialization.Model): +class MHSMPrivateEndpointConnectionItem(_serialization.Model): """Private endpoint connection item. :ivar id: Id of private endpoint connection. @@ -1251,23 +1195,26 @@ class MHSMPrivateEndpointConnectionItem(msrest.serialization.Model): :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", "Disconnected". + 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'}, + "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, + 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, @@ -1286,11 +1233,11 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnectionProvisioningState """ - super(MHSMPrivateEndpointConnectionItem, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id self.etag = etag self.private_endpoint = private_endpoint @@ -1298,7 +1245,7 @@ def __init__( self.provisioning_state = provisioning_state -class MHSMPrivateEndpointConnectionsListResult(msrest.serialization.Model): +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. @@ -1309,8 +1256,8 @@ class MHSMPrivateEndpointConnectionsListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[MHSMPrivateEndpointConnection]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[MHSMPrivateEndpointConnection]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( @@ -1327,7 +1274,7 @@ def __init__( :keyword next_link: The URL to get the next set of managed HSM Pools. :paramtype next_link: str """ - super(MHSMPrivateEndpointConnectionsListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link @@ -1347,7 +1294,7 @@ class MHSMPrivateLinkResource(ManagedHsmResource): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -1361,25 +1308,25 @@ class MHSMPrivateLinkResource(ManagedHsmResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'system_data': {'readonly': True}, - 'group_id': {'readonly': True}, - 'required_members': {'readonly': True}, + "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]'}, + "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__( @@ -1396,18 +1343,18 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :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(MHSMPrivateLinkResource, self).__init__(location=location, sku=sku, tags=tags, **kwargs) + 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(msrest.serialization.Model): +class MHSMPrivateLinkResourceListResult(_serialization.Model): """A list of private link resources. :ivar value: Array of private link resources. @@ -1415,42 +1362,37 @@ class MHSMPrivateLinkResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[MHSMPrivateLinkResource]'}, + "value": {"key": "value", "type": "[MHSMPrivateLinkResource]"}, } - def __init__( - self, - *, - value: Optional[List["_models.MHSMPrivateLinkResource"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.MHSMPrivateLinkResource"]] = None, **kwargs): """ :keyword value: Array of private link resources. :paramtype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateLinkResource] """ - super(MHSMPrivateLinkResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class MHSMPrivateLinkServiceConnectionState(msrest.serialization.Model): +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", "Disconnected". + 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. Known values are: "None". + 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'}, + "status": {"key": "status", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "actions_required": {"key": "actionsRequired", "type": "str"}, } def __init__( @@ -1463,66 +1405,63 @@ 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", "Disconnected". + 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. Known values are: "None". + updates on the consumer. "None" :paramtype actions_required: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.ActionsRequired """ - super(MHSMPrivateLinkServiceConnectionState, self).__init__(**kwargs) + super().__init__(**kwargs) self.status = status self.description = description self.actions_required = actions_required -class MHSMVirtualNetworkRule(msrest.serialization.Model): +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 Azure. - :ivar id: Required. Full resource id of a vnet subnet, such as + :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}, + "id": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - *, - id: str, - **kwargs - ): + def __init__(self, *, id: str, **kwargs): # pylint: disable=redefined-builtin """ - :keyword id: Required. Full resource id of a vnet subnet, such as + :keyword id: Full resource id of a vnet subnet, such as '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. + Required. :paramtype id: str """ - super(MHSMVirtualNetworkRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id -class NetworkRuleSet(msrest.serialization.Model): +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", + '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", "Deny". + "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. @@ -1533,10 +1472,10 @@ class NetworkRuleSet(msrest.serialization.Model): """ _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]'}, + "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__( @@ -1550,13 +1489,13 @@ 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", + '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", "Deny". + 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. @@ -1565,14 +1504,14 @@ def __init__( :paramtype virtual_network_rules: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.VirtualNetworkRule] """ - super(NetworkRuleSet, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class Operation(_serialization.Model): """Key Vault REST API operation definition. :ivar name: Operation name: {provider}/{resource}/{operation}. @@ -1589,11 +1528,11 @@ class Operation(msrest.serialization.Model): """ _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'}, + "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__( @@ -1619,7 +1558,7 @@ def __init__( :paramtype service_specification: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ServiceSpecification """ - super(Operation, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display = display self.origin = origin @@ -1627,7 +1566,7 @@ def __init__( self.service_specification = service_specification -class OperationDisplay(msrest.serialization.Model): +class OperationDisplay(_serialization.Model): """Display metadata associated with the operation. :ivar provider: Service provider: Microsoft Key Vault. @@ -1641,10 +1580,10 @@ class OperationDisplay(msrest.serialization.Model): """ _attribute_map = { - 'provider': {'key': 'provider', 'type': 'str'}, - 'resource': {'key': 'resource', 'type': 'str'}, - 'operation': {'key': 'operation', 'type': 'str'}, - 'description': {'key': 'description', 'type': 'str'}, + "provider": {"key": "provider", "type": "str"}, + "resource": {"key": "resource", "type": "str"}, + "operation": {"key": "operation", "type": "str"}, + "description": {"key": "description", "type": "str"}, } def __init__( @@ -1666,14 +1605,14 @@ def __init__( :keyword description: Description of operation. :paramtype description: str """ - super(OperationDisplay, self).__init__(**kwargs) + super().__init__(**kwargs) self.provider = provider self.resource = resource self.operation = operation self.description = description -class OperationListResult(msrest.serialization.Model): +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. @@ -1683,29 +1622,23 @@ class OperationListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Operation]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(OperationListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class Permissions(msrest.serialization.Model): +class Permissions(_serialization.Model): """Permissions the identity has for keys, secrets, certificates and storage. :ivar keys: Permissions to keys. @@ -1722,10 +1655,10 @@ class Permissions(msrest.serialization.Model): """ _attribute_map = { - 'keys': {'key': 'keys', 'type': '[str]'}, - 'secrets': {'key': 'secrets', 'type': '[str]'}, - 'certificates': {'key': 'certificates', 'type': '[str]'}, - 'storage': {'key': 'storage', 'type': '[str]'}, + "keys": {"key": "keys", "type": "[str]"}, + "secrets": {"key": "secrets", "type": "[str]"}, + "certificates": {"key": "certificates", "type": "[str]"}, + "storage": {"key": "storage", "type": "[str]"}, } def __init__( @@ -1750,14 +1683,14 @@ def __init__( :paramtype storage: list[str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.StoragePermissions] """ - super(Permissions, self).__init__(**kwargs) + super().__init__(**kwargs) self.keys = keys self.secrets = secrets self.certificates = certificates self.storage = storage -class PrivateEndpoint(msrest.serialization.Model): +class PrivateEndpoint(_serialization.Model): """Private endpoint object properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -1767,24 +1700,20 @@ class PrivateEndpoint(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, + "id": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(PrivateEndpoint, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None -class Resource(msrest.serialization.Model): +class Resource(_serialization.Model): """Key Vault resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -1797,33 +1726,29 @@ class Resource(msrest.serialization.Model): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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}, + "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}'}, + "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 - ): - """ - """ - super(Resource, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -1844,7 +1769,7 @@ class PrivateEndpointConnection(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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 @@ -1854,29 +1779,32 @@ class PrivateEndpointConnection(Resource): :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", "Disconnected". + 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}, + "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'}, + "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__( @@ -1897,18 +1825,18 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnectionProvisioningState """ - super(PrivateEndpointConnection, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class PrivateEndpointConnectionItem(_serialization.Model): """Private endpoint connection item. :ivar id: Id of private endpoint connection. @@ -1921,23 +1849,26 @@ class PrivateEndpointConnectionItem(msrest.serialization.Model): :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", "Disconnected". + 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'}, + "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, + 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, @@ -1955,11 +1886,11 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnectionProvisioningState """ - super(PrivateEndpointConnectionItem, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id self.etag = etag self.private_endpoint = private_endpoint @@ -1967,7 +1898,7 @@ def __init__( self.provisioning_state = provisioning_state -class PrivateEndpointConnectionListResult(msrest.serialization.Model): +class PrivateEndpointConnectionListResult(_serialization.Model): """List of private endpoint connections. :ivar value: The list of private endpoint connections. @@ -1977,8 +1908,8 @@ class PrivateEndpointConnectionListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[PrivateEndpointConnection]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[PrivateEndpointConnection]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( @@ -1995,7 +1926,7 @@ def __init__( :keyword next_link: The URL to get the next set of private endpoint connections. :paramtype next_link: str """ - super(PrivateEndpointConnectionListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link @@ -2013,7 +1944,7 @@ class PrivateLinkResource(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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 @@ -2024,43 +1955,38 @@ class PrivateLinkResource(Resource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'location': {'readonly': True}, - 'tags': {'readonly': True}, - 'group_id': {'readonly': True}, - 'required_members': {'readonly': True}, + "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]'}, + "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 - ): + def __init__(self, *, required_zone_names: Optional[List[str]] = None, **kwargs): """ :keyword required_zone_names: Required DNS zone names of the the private link resource. :paramtype required_zone_names: list[str] """ - super(PrivateLinkResource, self).__init__(**kwargs) + super().__init__(**kwargs) self.group_id = None self.required_members = None self.required_zone_names = required_zone_names -class PrivateLinkResourceListResult(msrest.serialization.Model): +class PrivateLinkResourceListResult(_serialization.Model): """A list of private link resources. :ivar value: Array of private link resources. @@ -2068,42 +1994,37 @@ class PrivateLinkResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[PrivateLinkResource]'}, + "value": {"key": "value", "type": "[PrivateLinkResource]"}, } - def __init__( - self, - *, - value: Optional[List["_models.PrivateLinkResource"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs): """ :keyword value: Array of private link resources. :paramtype value: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateLinkResource] """ - super(PrivateLinkResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class PrivateLinkServiceConnectionState(msrest.serialization.Model): +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", "Disconnected". + 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. Known values are: "None". + 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'}, + "status": {"key": "status", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "actions_required": {"key": "actionsRequired", "type": "str"}, } def __init__( @@ -2116,23 +2037,23 @@ 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", "Disconnected". + 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. Known values are: "None". + updates on the consumer. "None" :paramtype actions_required: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.ActionsRequired """ - super(PrivateLinkServiceConnectionState, self).__init__(**kwargs) + super().__init__(**kwargs) self.status = status self.description = description self.actions_required = actions_required -class ResourceListResult(msrest.serialization.Model): +class ResourceListResult(_serialization.Model): """List of vault resources. :ivar value: The list of vault resources. @@ -2142,29 +2063,23 @@ class ResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Resource]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Resource"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(ResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class ServiceSpecification(msrest.serialization.Model): +class ServiceSpecification(_serialization.Model): """One property of operation, include log specifications. :ivar log_specifications: Log specifications of operation. @@ -2176,8 +2091,8 @@ class ServiceSpecification(msrest.serialization.Model): """ _attribute_map = { - 'log_specifications': {'key': 'logSpecifications', 'type': '[LogSpecification]'}, - 'metric_specifications': {'key': 'metricSpecifications', 'type': '[MetricSpecification]'}, + "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, + "metric_specifications": {"key": "metricSpecifications", "type": "[MetricSpecification]"}, } def __init__( @@ -2195,66 +2110,60 @@ def __init__( :paramtype metric_specifications: list[~azure.mgmt.keyvault.v2021_04_01_preview.models.MetricSpecification] """ - super(ServiceSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.log_specifications = log_specifications self.metric_specifications = metric_specifications -class Sku(msrest.serialization.Model): +class Sku(_serialization.Model): """SKU details. All required parameters must be populated in order to send to Azure. - :ivar family: Required. SKU family name. Known values are: "A". + :ivar family: SKU family name. Required. "A" :vartype family: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.SkuFamily - :ivar name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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}, + "family": {"required": True}, + "name": {"required": True}, } _attribute_map = { - 'family': {'key': 'family', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, + "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 - ): + def __init__(self, *, family: Union[str, "_models.SkuFamily"], name: Union[str, "_models.SkuName"], **kwargs): """ - :keyword family: Required. SKU family name. Known values are: "A". + :keyword family: SKU family name. Required. "A" :paramtype family: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.SkuFamily - :keyword name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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(Sku, self).__init__(**kwargs) + super().__init__(**kwargs) self.family = family self.name = name -class SystemData(msrest.serialization.Model): +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", "Key". + 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", "Key". + 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). @@ -2262,12 +2171,12 @@ class SystemData(msrest.serialization.Model): """ _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'}, + "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__( @@ -2285,20 +2194,20 @@ def __init__( :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", "Key". + 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", "Key". + 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(SystemData, self).__init__(**kwargs) + super().__init__(**kwargs) self.created_by = created_by self.created_by_type = created_by_type self.created_at = created_at @@ -2307,7 +2216,7 @@ def __init__( self.last_modified_at = last_modified_at -class Vault(msrest.serialization.Model): +class Vault(_serialization.Model): """Resource information with extended details. Variables are only populated by the server, and will be ignored when sending a request. @@ -2322,30 +2231,30 @@ class Vault(msrest.serialization.Model): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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: Required. Properties of the vault. + :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}, + "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'}, + "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__( @@ -2359,12 +2268,12 @@ def __init__( """ :keyword location: Azure location of the key vault resource. :paramtype location: str - :keyword tags: A set of tags. Tags assigned to the key vault resource. + :keyword tags: Tags assigned to the key vault resource. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultProperties """ - super(Vault, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -2374,7 +2283,7 @@ def __init__( self.properties = properties -class VaultAccessPolicyParameters(msrest.serialization.Model): +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. @@ -2389,39 +2298,34 @@ class VaultAccessPolicyParameters(msrest.serialization.Model): :vartype type: str :ivar location: The resource type of the access policy. :vartype location: str - :ivar properties: Required. Properties of the access policy. + :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}, + "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'}, + "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 - ): + def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs): """ - :keyword properties: Required. Properties of the access policy. + :keyword properties: Properties of the access policy. Required. :paramtype properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyProperties """ - super(VaultAccessPolicyParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -2429,129 +2333,114 @@ def __init__( self.properties = properties -class VaultAccessPolicyProperties(msrest.serialization.Model): +class VaultAccessPolicyProperties(_serialization.Model): """Properties of the vault access policy. All required parameters must be populated in order to send to Azure. - :ivar access_policies: Required. 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. + :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}, + "access_policies": {"required": True}, } _attribute_map = { - 'access_policies': {'key': 'accessPolicies', 'type': '[AccessPolicyEntry]'}, + "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, } - def __init__( - self, - *, - access_policies: List["_models.AccessPolicyEntry"], - **kwargs - ): + def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwargs): """ - :keyword access_policies: Required. 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. + :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(VaultAccessPolicyProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.access_policies = access_policies -class VaultCheckNameAvailabilityParameters(msrest.serialization.Model): +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 Azure. - :ivar name: Required. The vault name. + :ivar name: The vault name. Required. :vartype name: str - :ivar type: The type of resource, Microsoft.KeyVault/vaults. Has constant value: + :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}, + "name": {"required": True}, + "type": {"required": True, "constant": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, } type = "Microsoft.KeyVault/vaults" - def __init__( - self, - *, - name: str, - **kwargs - ): + def __init__(self, *, name: str, **kwargs): """ - :keyword name: Required. The vault name. + :keyword name: The vault name. Required. :paramtype name: str """ - super(VaultCheckNameAvailabilityParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name -class VaultCreateOrUpdateParameters(msrest.serialization.Model): +class VaultCreateOrUpdateParameters(_serialization.Model): """Parameters for creating or updating a vault. All required parameters must be populated in order to send to Azure. - :ivar location: Required. The supported Azure location where the key vault should be created. + :ivar location: The supported Azure location where the key vault should be created. Required. :vartype location: str - :ivar tags: A set of tags. The tags that will be assigned to the key vault. + :ivar tags: The tags that will be assigned to the key vault. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the vault. + :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}, + "location": {"required": True}, + "properties": {"required": True}, } _attribute_map = { - 'location': {'key': 'location', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'VaultProperties'}, + "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 + self, *, location: str, properties: "_models.VaultProperties", tags: Optional[Dict[str, str]] = None, **kwargs ): """ - :keyword location: Required. The supported Azure location where the key vault should be - created. + :keyword location: The supported Azure location where the key vault should be created. + Required. :paramtype location: str - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :keyword tags: The tags that will be assigned to the key vault. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultProperties """ - super(VaultCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.location = location self.tags = tags self.properties = properties -class VaultListResult(msrest.serialization.Model): +class VaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of vaults. @@ -2561,40 +2450,34 @@ class VaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Vault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Vault"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(VaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class VaultPatchParameters(msrest.serialization.Model): +class VaultPatchParameters(_serialization.Model): """Parameters for creating or updating a vault. - :ivar tags: A set of tags. The tags that will be assigned to the key 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'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "VaultPatchProperties"}, } def __init__( @@ -2605,17 +2488,17 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :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(VaultPatchParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class VaultPatchProperties(msrest.serialization.Model): +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 @@ -2649,7 +2532,7 @@ class VaultPatchProperties(msrest.serialization.Model): :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", "default". + 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 @@ -2663,18 +2546,18 @@ class VaultPatchProperties(msrest.serialization.Model): """ _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'}, + "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__( @@ -2727,7 +2610,7 @@ def __init__( <=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", "default". + 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 @@ -2739,7 +2622,7 @@ def __init__( specific network locations. :paramtype network_acls: ~azure.mgmt.keyvault.v2021_04_01_preview.models.NetworkRuleSet """ - super(VaultPatchProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies @@ -2754,17 +2637,17 @@ def __init__( self.network_acls = network_acls -class VaultProperties(msrest.serialization.Model): +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 Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :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 @@ -2799,7 +2682,7 @@ class VaultProperties(msrest.serialization.Model): 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", "default". + 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 @@ -2810,7 +2693,7 @@ class VaultProperties(msrest.serialization.Model): :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", + :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 @@ -2821,29 +2704,32 @@ class VaultProperties(msrest.serialization.Model): """ _validation = { - 'tenant_id': {'required': True}, - 'sku': {'required': True}, - 'hsm_pool_resource_id': {'readonly': True}, - 'private_endpoint_connections': {'readonly': True}, + "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]'}, + "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__( @@ -2856,9 +2742,9 @@ def __init__( 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] = True, - soft_delete_retention_in_days: Optional[int] = 90, - enable_rbac_authorization: Optional[bool] = False, + 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, @@ -2866,10 +2752,10 @@ def __init__( **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :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 @@ -2903,7 +2789,7 @@ def __init__( 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", "default". + 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 @@ -2914,12 +2800,12 @@ def __init__( :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", + :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(VaultProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies @@ -2938,13 +2824,14 @@ def __init__( self.private_endpoint_connections = None -class VirtualNetworkRule(msrest.serialization.Model): +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 Azure. - :ivar id: Required. Full resource id of a vnet subnet, such as + :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. @@ -2952,29 +2839,30 @@ class VirtualNetworkRule(msrest.serialization.Model): """ _validation = { - 'id': {'required': True}, + "id": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'ignore_missing_vnet_service_endpoint': {'key': 'ignoreMissingVnetServiceEndpoint', 'type': 'bool'}, + "id": {"key": "id", "type": "str"}, + "ignore_missing_vnet_service_endpoint": {"key": "ignoreMissingVnetServiceEndpoint", "type": "bool"}, } def __init__( self, *, - id: str, + id: str, # pylint: disable=redefined-builtin ignore_missing_vnet_service_endpoint: Optional[bool] = None, **kwargs ): """ - :keyword id: Required. Full resource id of a vnet subnet, such as + :keyword id: Full resource id of a vnet subnet, such as '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. + 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(VirtualNetworkRule, self).__init__(**kwargs) + 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index 1ab91d2ad823..6acb1b876c98 100644 --- 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 @@ -17,14 +17,15 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'VaultsOperations', - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'ManagedHsmsOperations', - 'MHSMPrivateEndpointConnectionsOperations', - 'MHSMPrivateLinkResourcesOperations', - 'Operations', + "VaultsOperations", + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "ManagedHsmsOperations", + "MHSMPrivateEndpointConnectionsOperations", + "MHSMPrivateLinkResourcesOperations", + "Operations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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 index 7c805a1d11e0..b797559148a2 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,358 +28,281 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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_initial( - resource_group_name: str, - name: str, - subscription_id: str, - *, - json: Optional[_models.ManagedHsm] = None, - content: Any = None, - **kwargs: Any + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) - - -def build_update_request_initial( - resource_group_name: str, - name: str, - subscription_id: str, - *, - json: Optional[_models.ManagedHsm] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) - - -def build_delete_request_initial( - resource_group_name: str, - name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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["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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_list_deleted_request( - subscription_id: str, - **kwargs: Any -) -> HttpRequest: +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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["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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "name": _SERIALIZER.url("name", name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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_initial( - name: str, - location: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "name": _SERIALIZER.url("name", name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class ManagedHsmsOperations: """ @@ -394,36 +323,41 @@ def __init__(self, *args, **kwargs): 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") - def _create_or_update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -431,46 +365,51 @@ def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - - @distributed_trace + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. + :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 :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -482,20 +421,84 @@ def begin_create_or_update( :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 + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], **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 model type + or a IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -503,69 +506,71 @@ def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore def _update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_update_request_initial( + 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, - template_url=self._update_initial.metadata['url'], + content=_content, + template_url=self._update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -573,49 +578,54 @@ def _update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + 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 = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - - deserialized = self._deserialize('ManagedHsm', pipeline_response) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + _update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - - @distributed_trace + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to patch the managed HSM Pool. + :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 :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -627,20 +637,84 @@ def begin_update( :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 + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def begin_update( + self, + resource_group_name: str, + name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._update_initial( # type: ignore resource_group_name=resource_group_name, @@ -648,64 +722,59 @@ def begin_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore def _delete_initial( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any + self, resource_group_name: str, name: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_delete_request_initial( + request = build_delete_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -713,34 +782,29 @@ def _delete_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **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) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace - def begin_delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param name: The name of the managed HSM Pool to delete. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -752,92 +816,83 @@ def begin_delete( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore resource_group_name=resource_group_name, name=name, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> Optional[_models.ManagedHsm]: + 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. + :param name: The name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ManagedHsm, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.ManagedHsm]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.ManagedHsm]] - request = build_get_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -845,10 +900,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -858,56 +912,56 @@ def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -915,15 +969,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -940,10 +996,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -954,48 +1008,45 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -1003,14 +1054,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1027,10 +1081,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1041,44 +1093,42 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> Iterable[_models.DeletedManagedHsmListResult]: + def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedManagedHsm"]: """The List operation gets information about the deleted managed HSMs associated with the subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedManagedHsmListResult or the result of - cls(response) + :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.DeletedManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1086,13 +1136,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1109,10 +1163,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1123,48 +1175,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore @distributed_trace - def get_deleted( - self, - name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedManagedHsm: + 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. + :param name: The name of the deleted managed HSM. Required. :type name: str - :param location: The location of the deleted managed HSM. + :param location: The location of the deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedManagedHsm, or the result of cls(response) + :return: DeletedManagedHsm or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedManagedHsm - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsm] - request = build_get_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1172,10 +1219,9 @@ def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -1183,40 +1229,38 @@ def get_deleted( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DeletedManagedHsm', pipeline_response) + deserialized = self._deserialize("DeletedManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any + self, name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -1224,34 +1268,28 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore @distributed_trace - def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param name: The name of the soft-deleted managed HSM. Required. :type name: str - :param location: The location of the soft-deleted managed HSM. + :param location: The location of the soft-deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -1263,52 +1301,45 @@ def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._purge_deleted_initial( # type: ignore name=name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # 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 index 013bf679a1db..ddff455d7bc3 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,173 +28,151 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - subscription_id: str, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_put_request( - subscription_id: str, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - *, - json: Optional[_models.MHSMPrivateEndpointConnection] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) - - -def build_delete_request_initial( - subscription_id: str, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + _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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class MHSMPrivateEndpointConnectionsOperations: """ @@ -209,47 +193,48 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def list_by_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> Iterable[_models.MHSMPrivateEndpointConnectionsListResult]: + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either MHSMPrivateEndpointConnectionsListResult or the - result of cls(response) + :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.MHSMPrivateEndpointConnectionsListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -257,15 +242,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -282,10 +269,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -296,53 +281,50 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -350,10 +332,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -361,15 +342,78 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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( @@ -377,48 +421,64 @@ def put( resource_group_name: str, name: str, private_endpoint_connection_name: str, - properties: _models.MHSMPrivateEndpointConnection, + properties: Union[_models.MHSMPrivateEndpointConnection, IO], **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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :param properties: The intended state of private endpoint connection. Is either a model type or + a IO type. Required. :type properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - _json = self._serialize.body(properties, 'MHSMPrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -426,10 +486,9 @@ def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -437,45 +496,44 @@ def put( 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')) + 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) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore def _delete_initial( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.MHSMPrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -483,10 +541,9 @@ def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -496,37 +553,32 @@ def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def begin_delete( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -540,55 +592,48 @@ def begin_delete( result of cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 index 8a1fb4b3b6d9..50bb7c913a85 100644 --- 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 @@ -8,9 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,48 +24,46 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class MHSMPrivateLinkResourcesOperations: """ @@ -81,43 +84,42 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def list_by_mhsm_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateLinkResourceListResult, or the result of cls(response) + :return: MHSMPrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.MHSMPrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] - request = build_list_by_mhsm_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_mhsm_resource.metadata['url'], + template_url=self.list_by_mhsm_resource.metadata["url"], headers=_headers, params=_params, ) @@ -125,22 +127,20 @@ def list_by_mhsm_resource( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_mhsm_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # type: ignore - + list_by_mhsm_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # 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 index edb934cb4481..f6d714c5f83c 100644 --- 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 @@ -7,10 +7,16 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +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.pipeline.transport import HttpResponse @@ -20,38 +26,34 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request -T = TypeVar('T') + +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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class Operations: """ @@ -72,36 +74,35 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> Iterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -109,12 +110,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -131,10 +137,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -144,8 +148,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # type: ignore 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index bf4b63ea92bd..a1631b148de3 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,173 +28,163 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_put_request( - subscription_id: str, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, - *, - json: Optional[_models.PrivateEndpointConnection] = None, - content: Any = None, + subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) -def build_delete_request_initial( - subscription_id: str, +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_resource_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateEndpointConnectionsOperations: """ @@ -209,48 +205,45 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def get( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -258,10 +251,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -270,64 +262,140 @@ def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - @distributed_trace + @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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection or + IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - _json = self._serialize.body(properties, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "PrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -335,10 +403,9 @@ def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -346,45 +413,44 @@ def put( 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')) + 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore def _delete_initial( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -392,10 +458,9 @@ def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -405,37 +470,31 @@ def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def begin_delete( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -449,99 +508,93 @@ def begin_delete( of cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def list_by_resource( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> Iterable[_models.PrivateEndpointConnectionListResult]: + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either PrivateEndpointConnectionListResult or the result - of cls(response) + :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.PrivateEndpointConnectionListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnectionListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -549,15 +602,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -574,10 +629,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -587,8 +640,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore 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 index eead3e778034..2a0214efa71f 100644 --- 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 @@ -8,9 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,48 +24,46 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateLinkResourcesOperations: """ @@ -81,43 +84,41 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def list_by_vault( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateLinkResourceListResult, or the result of cls(response) + :return: PrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.PrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] - request = build_list_by_vault_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_vault.metadata['url'], + template_url=self.list_by_vault.metadata["url"], headers=_headers, params=_params, ) @@ -125,22 +126,20 @@ def list_by_vault( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_vault.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore - + list_by_vault.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # 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 index d744091e85d6..51d9dc71ee06 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,485 +28,382 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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_initial( - resource_group_name: str, - vault_name: str, - subscription_id: str, - *, - json: Optional[_models.VaultCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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, - *, - json: Optional[_models.VaultPatchParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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"], + operation_kind: Union[str, _models.AccessPolicyUpdateKind], subscription_id: str, - *, - json: Optional[_models.VaultAccessPolicyParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_purge_deleted_request_initial( - vault_name: str, - location: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + 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 + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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, *, + filter: Union[str, _models.Enum12], + api_version: Union[str, _models.Enum13], top: Optional[int] = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - filter = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - accept = _headers.pop('Accept', "application/json") + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') + _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') + _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 - ) + _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, - *, - json: Optional[_models.VaultCheckNameAvailabilityParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability") + _url = kwargs.pop( + "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability" + ) path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: """ @@ -521,36 +424,45 @@ def __init__(self, *args, **kwargs): 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") - def _create_or_update_initial( self, resource_group_name: str, vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **kwargs: Any ) -> _models.Vault: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -558,10 +470,9 @@ def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -569,35 +480,110 @@ def _create_or_update_initial( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :param parameters: Parameters to create or update the vault. Is either a model type or a IO + type. Required. :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultCreateOrUpdateParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -608,20 +594,17 @@ def begin_create_or_update( Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -629,74 +612,140 @@ def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -705,7 +754,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -713,10 +763,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -724,55 +773,54 @@ def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -780,10 +828,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -793,45 +840,42 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -839,64 +883,144 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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: _models.VaultAccessPolicyParameters, + operation_kind: Union[str, _models.AccessPolicyUpdateKind], + parameters: Union[_models.VaultAccessPolicyParameters, IO], **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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :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. + :param parameters: Access policy to merge into the vault. Is either a model type or a IO type. + Required. :type parameters: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -906,7 +1030,8 @@ def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -914,10 +1039,9 @@ def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -925,58 +1049,58 @@ def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -984,15 +1108,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1009,10 +1135,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1022,46 +1146,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -1069,14 +1190,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1093,10 +1217,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1106,43 +1228,41 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> Iterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) + :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.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1150,13 +1270,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1173,10 +1297,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1186,48 +1308,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace - def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1235,50 +1352,47 @@ def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -1286,10 +1400,9 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -1299,21 +1412,15 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace - def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -1325,99 +1432,93 @@ def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace def list( self, + filter: Union[str, _models.Enum12], + api_version: Union[str, _models.Enum13], top: Optional[int] = None, **kwargs: Any - ) -> Iterable[_models.ResourceListResult]: + ) -> Iterable["_models.Resource"]: """The List operation gets information about the vaults associated with the subscription. + :param filter: The filter to apply on the operation. "resourceType eq + 'Microsoft.KeyVault/vaults'" Required. + :type filter: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.Enum12 + :param api_version: Azure Resource Manager Api Version. "2015-11-01" Required. + :type api_version: str or ~azure.mgmt.keyvault.v2021_04_01_preview.models.Enum13 :param top: Maximum number of results to return. Default value is None. :type top: int - :keyword filter: The filter to apply on the operation. Default value is "resourceType eq - 'Microsoft.KeyVault/vaults'". Note that overriding this default value may result in unsupported - behavior. - :paramtype filter: str - :keyword api_version: Azure Resource Manager Api Version. Default value is "2015-11-01". Note - that overriding this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_04_01_preview.models.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 {}) + _params = kwargs.pop("params", {}) or {} - filter = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, filter=filter, api_version=api_version, top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -1425,15 +1526,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1450,10 +1553,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1463,48 +1564,96 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace + @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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_04_01_preview.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def check_name_availability( + self, vault_name: IO, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], **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 model type or a IO type. Required. + :type vault_name: + ~azure.mgmt.keyvault.v2021_04_01_preview.models.VaultCheckNameAvailabilityParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-04-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-04-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1512,22 +1661,20 @@ def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore 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 index d19915ab3650..731fc6d4be82 100644 --- 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 @@ -17,7 +17,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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 index 08e3bd25fc62..5496334b9cbb 100644 --- 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 @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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: + def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2021-06-01-preview") # type: str + api_version = kwargs.pop("api_version", "2021-06-01-preview") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,23 +47,24 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) self._configure(**kwargs) def _configure( - self, - **kwargs # type: Any + self, **kwargs # type: Any ): # type: (...) -> 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.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs) + 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) + 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 index d8af90513778..0a59811dbc28 100644 --- 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 @@ -9,20 +9,30 @@ from copy import deepcopy from typing import Any, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import HttpRequest, HttpResponse from azure.mgmt.core import ARMPipelineClient from . import models +from .._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration -from .operations import KeysOperations, MHSMPrivateEndpointConnectionsOperations, MHSMPrivateLinkResourcesOperations, ManagedHsmsOperations, Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, SecretsOperations, VaultsOperations +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=too-many-instance-attributes + +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. @@ -48,10 +58,10 @@ class KeyVaultManagementClient: # pylint: disable=too-many-instance-attribute :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. + :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. + 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 @@ -69,47 +79,34 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = ARMPipelineClient(base_url=base_url, config=self._config, **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 - ) - self.vaults = VaultsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize) + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) self.private_endpoint_connections = PrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.managed_hsms = ManagedHsmsOperations(self._client, self._config, self._serialize, self._deserialize) self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - self.secrets = SecretsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) + self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize) - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> HttpResponse: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -118,7 +115,7 @@ def _send_request( >>> response = client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 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 index c52d6954f189..fd60863cabb9 100644 --- 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 @@ -10,20 +10,20 @@ "azure_arm": true, "has_lro_operations": true, "client_side_validation": false, - "sync_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"ARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}", - "async_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"], \"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"AsyncARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}" + "sync_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"ARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \".._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", + "async_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"AsyncARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \"..._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" }, "global_parameters": { "sync": { "credential": { - "signature": "credential, # type: \"TokenCredential\"", - "description": "Credential needed for the client to connect to Azure.", + "signature": "credential: \"TokenCredential\",", + "description": "Credential needed for the client to connect to Azure. Required.", "docstring_type": "~azure.core.credentials.TokenCredential", "required": true }, "subscription_id": { - "signature": "subscription_id, # type: str", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.", + "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 } @@ -31,13 +31,13 @@ "async": { "credential": { "signature": "credential: \"AsyncTokenCredential\",", - "description": "Credential needed for the client to connect to Azure.", + "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.", + "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 } @@ -54,7 +54,7 @@ "required": false }, "base_url": { - "signature": "base_url=\"https://management.azure.com\", # type: str", + "signature": "base_url: str = \"https://management.azure.com\",", "description": "Service URL", "docstring_type": "str", "required": false 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 index 74e48ecd07cf..f99e77fef986 100644 --- 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 @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_vendor.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_vendor.py index 138f663c53a4..9aad73fc743e 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_vendor.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_06_01_preview/_vendor.py @@ -7,6 +7,7 @@ from azure.core.pipeline.transport import HttpRequest + def _convert_request(request, files=None): data = request.content if not files else None request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) @@ -14,6 +15,7 @@ def _convert_request(request, files=None): request.set_formdata_body(files) return request + def _format_url_section(template, **kwargs): components = template.split("/") while components: @@ -21,7 +23,5 @@ def _format_url_section(template, **kwargs): return template.format(**kwargs) except KeyError as key: formatted_components = template.split("/") - components = [ - c for c in formatted_components if "{}".format(key.args[0]) not in c - ] + components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] template = "/".join(components) 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 index c1257f7f4e11..e5754a47ce68 100644 --- 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 @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "10.1.0" +VERSION = "1.0.0b1" 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 index 1aa2a0b291a3..c2c64fd1638f 100644 --- 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 @@ -14,7 +14,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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 index dc92ecf3ba17..051d3adfcbd5 100644 --- 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 @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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: + def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2021-06-01-preview") # type: str + api_version = kwargs.pop("api_version", "2021-06-01-preview") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,22 +47,21 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) 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.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) + 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) + 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 index 626262d5826c..dde164e274bc 100644 --- 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 @@ -9,20 +9,30 @@ from copy import deepcopy from typing import Any, Awaitable, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.mgmt.core import AsyncARMPipelineClient from .. import models +from ..._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration -from .operations import KeysOperations, MHSMPrivateEndpointConnectionsOperations, MHSMPrivateLinkResourcesOperations, ManagedHsmsOperations, Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, SecretsOperations, VaultsOperations +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=too-many-instance-attributes + +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. @@ -49,10 +59,10 @@ class KeyVaultManagementClient: # pylint: disable=too-many-instance-attribute :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. + :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. + 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 @@ -70,47 +80,34 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **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 - ) - self.vaults = VaultsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize) + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) self.private_endpoint_connections = PrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.managed_hsms = ManagedHsmsOperations(self._client, self._config, self._serialize, self._deserialize) self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - self.secrets = SecretsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) + self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize) - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -119,7 +116,7 @@ def _send_request( >>> response = await client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 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 index 74e48ecd07cf..f99e77fef986 100644 --- 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 @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass 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 index 49be258e3efc..9e5cd053e465 100644 --- 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 @@ -19,16 +19,17 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'KeysOperations', - 'VaultsOperations', - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'ManagedHsmsOperations', - 'MHSMPrivateEndpointConnectionsOperations', - 'MHSMPrivateLinkResourcesOperations', - 'Operations', - 'SecretsOperations', + "KeysOperations", + "VaultsOperations", + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "ManagedHsmsOperations", + "MHSMPrivateEndpointConnectionsOperations", + "MHSMPrivateLinkResourcesOperations", + "Operations", + "SecretsOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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 index 1d78ac893f9c..6bd0e0d7bc27 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,10 +28,18 @@ from ... import models as _models from ..._vendor import _convert_request -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 -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class KeysOperations: """ .. warning:: @@ -43,14 +59,15 @@ def __init__(self, *args, **kwargs) -> None: 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") - - @distributed_trace_async + @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 @@ -58,42 +75,120 @@ async def create_if_not_exist( subsequent versions, and does not update existing keys. :param resource_group_name: The name of the resource group which contains the specified key - vault. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. + :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. + :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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or a + IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - _json = self._serialize.body(parameters, 'KeyCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "KeyCreateParameters") request = build_create_if_not_exist_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.create_if_not_exist.metadata['url'], + content=_content, + template_url=self.create_if_not_exist.metadata["url"], headers=_headers, params=_params, ) @@ -101,67 +196,61 @@ async def create_if_not_exist( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_if_not_exist.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + create_if_not_exist.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> _models.Key: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. + :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. + :param key_name: The name of the key to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -169,65 +258,62 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace - def list( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.KeyListResult]: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. + :param vault_name: The name of the vault which contains the keys to be retrieved. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) + :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.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -235,15 +321,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -260,10 +348,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -273,57 +359,53 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore @distributed_trace_async async def get_version( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - key_version: str, - **kwargs: Any + 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. + 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. + :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. + :param key_version: The version of the key to be retrieved. Required. :type key_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_version_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get_version.metadata['url'], + template_url=self.get_version.metadata["url"], headers=_headers, params=_params, ) @@ -331,69 +413,68 @@ async def get_version( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_version.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore - + get_version.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore @distributed_trace def list_versions( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.KeyListResult]: + 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. + 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. + :param key_name: The name of the key versions to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) + :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.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_versions_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_versions.metadata['url'], + template_url=self.list_versions.metadata["url"], headers=_headers, params=_params, ) @@ -401,16 +482,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_versions_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -427,10 +509,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -440,8 +520,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_versions.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore + list_versions.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore 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 index a48e064ef39e..1987d800aded 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,22 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._managed_hsms_operations import build_create_or_update_request_initial, build_delete_request_initial, 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_initial, build_update_request_initial -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class ManagedHsmsOperations: """ .. warning:: @@ -45,36 +65,41 @@ def __init__(self, *args, **kwargs) -> None: 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") - async def _create_or_update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -82,46 +107,120 @@ async def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - @distributed_trace_async + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], **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 model type + or a IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -134,20 +233,17 @@ async def begin_create_or_update( cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -155,69 +251,71 @@ async def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore async def _update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_update_request_initial( + 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, - template_url=self._update_initial.metadata['url'], + content=_content, + template_url=self._update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -225,49 +323,54 @@ async def _update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + 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 = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - - deserialized = self._deserialize('ManagedHsm', pipeline_response) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + _update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - - @distributed_trace_async + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to patch the managed HSM Pool. + :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 :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -280,20 +383,86 @@ async def begin_update( cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def begin_update( + self, + resource_group_name: str, + name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._update_initial( # type: ignore resource_group_name=resource_group_name, @@ -301,64 +470,59 @@ async def begin_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore async def _delete_initial( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any + self, resource_group_name: str, name: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_delete_request_initial( + request = build_delete_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -366,34 +530,29 @@ async def _delete_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **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) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace_async - async def begin_delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param name: The name of the managed HSM Pool to delete. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -405,92 +564,83 @@ async def begin_delete( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore resource_group_name=resource_group_name, name=name, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> Optional[_models.ManagedHsm]: + 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. + :param name: The name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ManagedHsm, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.ManagedHsm]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.ManagedHsm]] - request = build_get_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -498,10 +648,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -511,56 +660,56 @@ async def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -568,15 +717,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -593,10 +744,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -607,48 +756,45 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -656,14 +802,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -680,10 +829,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -694,44 +841,42 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> AsyncIterable[_models.DeletedManagedHsmListResult]: + def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedManagedHsm"]: """The List operation gets information about the deleted managed HSMs associated with the subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedManagedHsmListResult or the result of - cls(response) + :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.DeletedManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -739,13 +884,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -762,10 +911,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -776,48 +923,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore @distributed_trace_async - async def get_deleted( - self, - name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedManagedHsm: + 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. + :param name: The name of the deleted managed HSM. Required. :type name: str - :param location: The location of the deleted managed HSM. + :param location: The location of the deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedManagedHsm, or the result of cls(response) + :return: DeletedManagedHsm or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedManagedHsm - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsm] - request = build_get_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -825,10 +967,9 @@ async def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -836,40 +977,38 @@ async def get_deleted( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DeletedManagedHsm', pipeline_response) + deserialized = self._deserialize("DeletedManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore async def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any + self, name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -877,34 +1016,28 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore @distributed_trace_async - async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param name: The name of the soft-deleted managed HSM. Required. :type name: str - :param location: The location of the soft-deleted managed HSM. + :param location: The location of the soft-deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -916,52 +1049,45 @@ async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._purge_deleted_initial( # type: ignore name=name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # 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 index 3aa1cd9f773b..317b1ce4584f 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,17 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._mhsm_private_endpoint_connections_operations import build_delete_request_initial, build_get_request, build_list_by_resource_request, build_put_request -T = TypeVar('T') +from ...operations._mhsm_private_endpoint_connections_operations import ( + build_delete_request, + build_get_request, + build_list_by_resource_request, + build_put_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class MHSMPrivateEndpointConnectionsOperations: """ .. warning:: @@ -45,47 +60,48 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace def list_by_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> AsyncIterable[_models.MHSMPrivateEndpointConnectionsListResult]: + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either MHSMPrivateEndpointConnectionsListResult or the - result of cls(response) + :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.MHSMPrivateEndpointConnectionsListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -93,15 +109,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -118,10 +136,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -132,53 +148,50 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -186,10 +199,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -197,15 +209,78 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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( @@ -213,48 +288,64 @@ async def put( resource_group_name: str, name: str, private_endpoint_connection_name: str, - properties: _models.MHSMPrivateEndpointConnection, + properties: Union[_models.MHSMPrivateEndpointConnection, IO], **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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :param properties: The intended state of private endpoint connection. Is either a model type or + a IO type. Required. :type properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - _json = self._serialize.body(properties, 'MHSMPrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -262,10 +353,9 @@ async def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -273,45 +363,44 @@ async def put( 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')) + 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) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore async def _delete_initial( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.MHSMPrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -319,10 +408,9 @@ async def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -332,37 +420,32 @@ async def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace_async async def begin_delete( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -376,55 +459,48 @@ async def begin_delete( result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 index 5094486e9912..7617215d8cc1 100644 --- 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 @@ -8,7 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -19,9 +26,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._mhsm_private_link_resources_operations import build_list_by_mhsm_resource_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class MHSMPrivateLinkResourcesOperations: """ .. warning:: @@ -41,43 +50,42 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def list_by_mhsm_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateLinkResourceListResult, or the result of cls(response) + :return: MHSMPrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] - request = build_list_by_mhsm_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_mhsm_resource.metadata['url'], + template_url=self.list_by_mhsm_resource.metadata["url"], headers=_headers, params=_params, ) @@ -85,22 +93,20 @@ async def list_by_mhsm_resource( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_mhsm_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # type: ignore - + list_by_mhsm_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # 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 index 2dbad436f634..2155d6542440 100644 --- 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 @@ -7,9 +7,17 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,9 +28,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._operations import build_list_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class Operations: """ .. warning:: @@ -42,36 +52,36 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> AsyncIterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) + :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.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -79,12 +89,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -101,10 +116,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -114,8 +127,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # type: ignore 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index b58cce938b38..dbfe9cab842b 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,17 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._private_endpoint_connections_operations import build_delete_request_initial, build_get_request, build_list_by_resource_request, build_put_request -T = TypeVar('T') +from ...operations._private_endpoint_connections_operations import ( + build_delete_request, + build_get_request, + build_list_by_resource_request, + build_put_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateEndpointConnectionsOperations: """ .. warning:: @@ -45,48 +60,45 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def get( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -94,10 +106,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -106,64 +117,140 @@ async def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - @distributed_trace_async + @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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection or + IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - _json = self._serialize.body(properties, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "PrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -171,10 +258,9 @@ async def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -182,45 +268,44 @@ async def put( 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')) + 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore async def _delete_initial( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -228,10 +313,9 @@ async def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -241,37 +325,31 @@ async def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace_async async def begin_delete( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -285,99 +363,93 @@ async def begin_delete( result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def list_by_resource( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.PrivateEndpointConnectionListResult]: + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either PrivateEndpointConnectionListResult or the result - of cls(response) + :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.PrivateEndpointConnectionListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnectionListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -385,15 +457,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -410,10 +484,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -423,8 +495,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore 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 index 7657ba2e2d7b..aaba24c6c2ca 100644 --- 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 @@ -8,7 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -19,9 +26,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._private_link_resources_operations import build_list_by_vault_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateLinkResourcesOperations: """ .. warning:: @@ -41,43 +50,41 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def list_by_vault( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateLinkResourceListResult, or the result of cls(response) + :return: PrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] - request = build_list_by_vault_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_vault.metadata['url'], + template_url=self.list_by_vault.metadata["url"], headers=_headers, params=_params, ) @@ -85,22 +92,20 @@ async def list_by_vault( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_vault.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore - + list_by_vault.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # 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 index 67e198f2f99d..6435d3dcbb97 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,10 +28,17 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._secrets_operations import build_create_or_update_request, build_get_request, build_list_request, build_update_request -T = TypeVar('T') +from ...operations._secrets_operations import ( + build_create_or_update_request, + build_get_request, + build_list_request, + build_update_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class SecretsOperations: """ .. warning:: @@ -43,14 +58,15 @@ def __init__(self, *args, **kwargs) -> None: 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") - - @distributed_trace_async + @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 @@ -58,32 +74,111 @@ async def create_or_update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :param secret_name: Name of the secret. Required. :type secret_name: str - :param parameters: Parameters to create or update the secret. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + vault_name: str, + secret_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO + type. Required. + :type parameters: + ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -93,7 +188,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -101,10 +197,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -112,26 +207,27 @@ async def create_or_update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - @distributed_trace_async + @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 @@ -139,31 +235,109 @@ async def update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :param secret_name: Name of the secret. Required. :type secret_name: str - :param parameters: Parameters to patch the secret. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update( + self, + resource_group_name: str, + vault_name: str, + secret_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -173,7 +347,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -181,10 +356,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -192,60 +366,56 @@ async def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - **kwargs: Any - ) -> _models.Secret: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param secret_name: The name of the secret. + :param secret_name: The name of the secret. Required. :type secret_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -253,70 +423,69 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace def list( - self, - resource_group_name: str, - vault_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.SecretListResult]: + 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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SecretListResult or the result of cls(response) + :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.SecretListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SecretListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SecretListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, top=top, - template_url=self.list.metadata['url'], + api_version=api_version, + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -324,16 +493,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -350,10 +520,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -363,8 +531,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore 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 index 25d7521388bb..4c9c30a59668 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,25 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._vaults_operations import build_check_name_availability_request, build_create_or_update_request_initial, 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_initial, build_update_access_policy_request, build_update_request -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class VaultsOperations: """ .. warning:: @@ -45,36 +68,45 @@ def __init__(self, *args, **kwargs) -> None: 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") - async def _create_or_update_initial( self, resource_group_name: str, vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **kwargs: Any ) -> _models.Vault: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -82,10 +114,9 @@ async def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -93,35 +124,112 @@ async def _create_or_update_initial( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :param parameters: Parameters to create or update the vault. Is either a model type or a IO + type. Required. :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultCreateOrUpdateParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -133,20 +241,17 @@ async def begin_create_or_update( :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -154,74 +259,140 @@ async def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace_async + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -230,7 +401,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -238,10 +410,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -249,55 +420,54 @@ async def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -305,10 +475,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -318,45 +487,42 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -364,64 +530,144 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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: _models.VaultAccessPolicyParameters, + operation_kind: Union[str, _models.AccessPolicyUpdateKind], + parameters: Union[_models.VaultAccessPolicyParameters, IO], **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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :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. + :param parameters: Access policy to merge into the vault. Is either a model type or a IO type. + Required. :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -431,7 +677,8 @@ async def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -439,10 +686,9 @@ async def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -450,58 +696,59 @@ async def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) + :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.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -509,15 +756,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -534,10 +783,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -547,46 +794,44 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) + :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.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -594,14 +839,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -618,10 +866,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -631,43 +877,41 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> AsyncIterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) + :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.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -675,13 +919,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -698,10 +946,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -711,48 +957,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace_async - async def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -760,50 +1001,47 @@ async def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore async def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -811,10 +1049,9 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -824,21 +1061,15 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace_async - async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -850,62 +1081,51 @@ async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace - def list( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.ResourceListResult]: + 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. @@ -918,31 +1138,37 @@ def list( that overriding this default value may result in unsupported behavior. :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) + :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.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + filter = kwargs.pop( + "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") + ) # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -950,15 +1176,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -975,10 +1203,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -988,48 +1214,96 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace_async + @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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def check_name_availability( + self, vault_name: IO, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], **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 model type or a IO type. Required. + :type vault_name: + ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultCheckNameAvailabilityParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1037,22 +1311,20 @@ async def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # 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 index 4bde73eeaac9..230a73347485 100644 --- 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 @@ -83,139 +83,137 @@ from ._models_py3 import VaultProperties from ._models_py3 import VirtualNetworkRule - -from ._key_vault_management_client_enums import ( - 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, -) +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 * # type: ignore # 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', + "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() \ No newline at end of file +_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 index ce161ebed7bc..da56bf73baa2 100644 --- 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 @@ -11,25 +11,28 @@ 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. - """ + """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_ENUM = "import" + IMPORT = "import" UPDATE = "update" MANAGECONTACTS = "managecontacts" GETISSUERS = "getissuers" @@ -42,13 +45,14 @@ class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): BACKUP = "backup" RESTORE = "restore" + class CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The vault's create mode to indicate whether the vault need to be recovered or not. - """ + """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 @@ -60,24 +64,25 @@ class DeletionRecoveryLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta): RECOVERABLE = "Recoverable" RECOVERABLE_PROTECTED_SUBSCRIPTION = "Recoverable+ProtectedSubscription" + class IdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of identity. - """ + """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. - """ + """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. @@ -89,19 +94,21 @@ class JsonWebKeyOperation(str, Enum, metaclass=CaseInsensitiveEnumMeta): VERIFY = "verify" WRAP_KEY = "wrapKey" UNWRAP_KEY = "unwrapKey" - IMPORT_ENUM = "import" + IMPORT = "import" RELEASE = "release" + class JsonWebKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of the key. For valid values, see JsonWebKeyType. - """ + """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" @@ -114,7 +121,7 @@ class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): LIST = "list" CREATE = "create" UPDATE = "update" - IMPORT_ENUM = "import" + IMPORT = "import" DELETE = "delete" BACKUP = "backup" RESTORE = "restore" @@ -125,26 +132,27 @@ class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): SETROTATIONPOLICY = "setrotationpolicy" RELEASE = "release" + class KeyRotationPolicyActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of action. - """ + """The type of action.""" ROTATE = "rotate" NOTIFY = "notify" + class ManagedHsmSkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU Family of the managed HSM Pool - """ + """SKU Family of the managed HSM Pool.""" B = "B" + class ManagedHsmSkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU of the managed HSM Pool - """ + """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. @@ -153,6 +161,7 @@ class NetworkRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta): 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'. @@ -161,9 +170,9 @@ class NetworkRuleBypassOptions(str, Enum, metaclass=CaseInsensitiveEnumMeta): AZURE_SERVICES = "AzureServices" NONE = "None" + class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The current provisioning state. - """ + """The current provisioning state.""" SUCCEEDED = "Succeeded" CREATING = "Creating" @@ -172,18 +181,18 @@ class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsens FAILED = "Failed" DISCONNECTED = "Disconnected" + class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The private endpoint connection status. - """ + """The private endpoint connection status.""" PENDING = "Pending" APPROVED = "Approved" REJECTED = "Rejected" DISCONNECTED = "Disconnected" + class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state. - """ + """Provisioning state.""" #: The managed HSM Pool has been full provisioned. SUCCEEDED = "Succeeded" @@ -202,6 +211,7 @@ class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): #: The managed HSM pool is being restored from full HSM backup. RESTORING = "Restoring" + class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Control permission for data plane traffic coming from public networks while private endpoint is enabled. @@ -210,6 +220,7 @@ class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta): 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. @@ -218,7 +229,9 @@ class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta): ACCOUNT_NAME_INVALID = "AccountNameInvalid" ALREADY_EXISTS = "AlreadyExists" + class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """SecretPermissions.""" ALL = "all" GET = "get" @@ -230,20 +243,22 @@ class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): RECOVER = "recover" PURGE = "purge" + class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU family name - """ + """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. - """ + """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" @@ -261,9 +276,9 @@ class StoragePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): GETSAS = "getsas" DELETESAS = "deletesas" + class VaultProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state of the vault. - """ + """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 index b7f8c38d5287..7a7184c09199 100644 --- 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 @@ -1,4 +1,5 @@ # 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. @@ -9,43 +10,42 @@ import datetime from typing import Dict, List, Optional, TYPE_CHECKING, Union -from azure.core.exceptions import HttpResponseError -import msrest.serialization +from ... import _serialization if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - import __init__ as _models + from .. import models as _models -class AccessPolicyEntry(msrest.serialization.Model): +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 Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and certificates. + :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}, + "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'}, + "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__( @@ -58,54 +58,49 @@ def __init__( **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and - certificates. + :keyword permissions: Permissions the identity has for keys, secrets and certificates. + Required. :paramtype permissions: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Permissions """ - super(AccessPolicyEntry, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.object_id = object_id self.application_id = application_id self.permissions = permissions -class Action(msrest.serialization.Model): +class Action(_serialization.Model): """Action. - :ivar type: The type of action. Known values are: "rotate", "notify". + :ivar type: The type of action. 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'}, + "type": {"key": "type", "type": "str"}, } - def __init__( - self, - *, - type: Optional[Union[str, "_models.KeyRotationPolicyActionType"]] = None, - **kwargs - ): + def __init__(self, *, type: Optional[Union[str, "_models.KeyRotationPolicyActionType"]] = None, **kwargs): """ - :keyword type: The type of action. Known values are: "rotate", "notify". + :keyword type: The type of action. Known values are: "rotate" and "notify". :paramtype type: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyRotationPolicyActionType """ - super(Action, self).__init__(**kwargs) + super().__init__(**kwargs) self.type = type -class Attributes(msrest.serialization.Model): +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. @@ -123,16 +118,16 @@ class Attributes(msrest.serialization.Model): """ _validation = { - 'created': {'readonly': True}, - 'updated': {'readonly': True}, + "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'}, + "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__( @@ -151,7 +146,7 @@ def __init__( :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. :paramtype expires: ~datetime.datetime """ - super(Attributes, self).__init__(**kwargs) + super().__init__(**kwargs) self.enabled = enabled self.not_before = not_before self.expires = expires @@ -159,7 +154,7 @@ def __init__( self.updated = None -class CheckNameAvailabilityResult(msrest.serialization.Model): +class CheckNameAvailabilityResult(_serialization.Model): """The CheckNameAvailability operation response. Variables are only populated by the server, and will be ignored when sending a request. @@ -169,37 +164,33 @@ class CheckNameAvailabilityResult(msrest.serialization.Model): 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", "AlreadyExists". + 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}, + "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'}, + "name_available": {"key": "nameAvailable", "type": "bool"}, + "reason": {"key": "reason", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(CheckNameAvailabilityResult, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.name_available = None self.reason = None self.message = None -class CloudErrorBody(msrest.serialization.Model): +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. @@ -210,17 +201,11 @@ class CloudErrorBody(msrest.serialization.Model): """ _attribute_map = { - 'code': {'key': 'code', 'type': 'str'}, - 'message': {'key': 'message', 'type': 'str'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - *, - code: Optional[str] = None, - message: Optional[str] = None, - **kwargs - ): + def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs): """ :keyword code: Error code. This is a mnemonic that can be consumed programmatically. :paramtype code: str @@ -228,12 +213,12 @@ def __init__( with service version. :paramtype message: str """ - super(CloudErrorBody, self).__init__(**kwargs) + super().__init__(**kwargs) self.code = code self.message = message -class DeletedManagedHsm(msrest.serialization.Model): +class DeletedManagedHsm(_serialization.Model): """DeletedManagedHsm. Variables are only populated by the server, and will be ignored when sending a request. @@ -250,37 +235,32 @@ class DeletedManagedHsm(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "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'}, + "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 - ): + def __init__(self, *, properties: Optional["_models.DeletedManagedHsmProperties"] = None, **kwargs): """ :keyword properties: Properties of the deleted managed HSM. :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedManagedHsmProperties """ - super(DeletedManagedHsm, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None self.properties = properties -class DeletedManagedHsmListResult(msrest.serialization.Model): +class DeletedManagedHsmListResult(_serialization.Model): """List of deleted managed HSM Pools. :ivar value: The list of deleted managed HSM Pools. @@ -290,16 +270,12 @@ class DeletedManagedHsmListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DeletedManagedHsm]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.DeletedManagedHsm"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of deleted managed HSM Pools. @@ -307,12 +283,12 @@ def __init__( :keyword next_link: The URL to get the next set of deleted managed HSM Pools. :paramtype next_link: str """ - super(DeletedManagedHsmListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class DeletedManagedHsmProperties(msrest.serialization.Model): +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. @@ -327,35 +303,31 @@ class DeletedManagedHsmProperties(msrest.serialization.Model): :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: A set of tags. Tags of the original managed HSM. + :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}, + "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}'}, + "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 - ): - """ - """ - super(DeletedManagedHsmProperties, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.mhsm_id = None self.location = None self.deletion_date = None @@ -364,7 +336,7 @@ def __init__( self.tags = None -class DeletedVault(msrest.serialization.Model): +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. @@ -380,36 +352,31 @@ class DeletedVault(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "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'}, + "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 - ): + def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs): """ :keyword properties: Properties of the vault. :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedVaultProperties """ - super(DeletedVault, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None self.properties = properties -class DeletedVaultListResult(msrest.serialization.Model): +class DeletedVaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of deleted vaults. @@ -419,16 +386,12 @@ class DeletedVaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DeletedVault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.DeletedVault"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of deleted vaults. @@ -436,12 +399,12 @@ def __init__( :keyword next_link: The URL to get the next set of deleted vaults. :paramtype next_link: str """ - super(DeletedVaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class DeletedVaultProperties(msrest.serialization.Model): +class DeletedVaultProperties(_serialization.Model): """Properties of the deleted vault. Variables are only populated by the server, and will be ignored when sending a request. @@ -454,37 +417,33 @@ class DeletedVaultProperties(msrest.serialization.Model): :vartype deletion_date: ~datetime.datetime :ivar scheduled_purge_date: The scheduled purged date. :vartype scheduled_purge_date: ~datetime.datetime - :ivar tags: A set of tags. Tags of the original vault. + :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}, + "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'}, + "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 - ): - """ - """ - super(DeletedVaultProperties, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.vault_id = None self.location = None self.deletion_date = None @@ -493,7 +452,7 @@ def __init__( self.purge_protection_enabled = None -class DimensionProperties(msrest.serialization.Model): +class DimensionProperties(_serialization.Model): """Type of operation: get, read, delete, etc. :ivar name: Name of dimension. @@ -506,9 +465,9 @@ class DimensionProperties(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'to_be_exported_for_shoebox': {'key': 'toBeExportedForShoebox', 'type': 'bool'}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "to_be_exported_for_shoebox": {"key": "toBeExportedForShoebox", "type": "bool"}, } def __init__( @@ -528,13 +487,13 @@ def __init__( exported for Shoebox. :paramtype to_be_exported_for_shoebox: bool """ - super(DimensionProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.to_be_exported_for_shoebox = to_be_exported_for_shoebox -class Error(msrest.serialization.Model): +class Error(_serialization.Model): """The server error. Variables are only populated by the server, and will be ignored when sending a request. @@ -548,63 +507,54 @@ class Error(msrest.serialization.Model): """ _validation = { - 'code': {'readonly': True}, - 'message': {'readonly': True}, - 'inner_error': {'readonly': True}, + "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'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, + "inner_error": {"key": "innererror", "type": "Error"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(Error, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.code = None self.message = None self.inner_error = None -class IPRule(msrest.serialization.Model): +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 Azure. - :ivar value: Required. 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). + :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}, + "value": {"required": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, + "value": {"key": "value", "type": "str"}, } - def __init__( - self, - *, - value: str, - **kwargs - ): + def __init__(self, *, value: str, **kwargs): """ - :keyword value: Required. 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). + :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(IPRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class Resource(msrest.serialization.Model): +class Resource(_serialization.Model): """Key Vault resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -617,33 +567,29 @@ class Resource(msrest.serialization.Model): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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}, + "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}'}, + "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 - ): - """ - """ - super(Resource, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -651,7 +597,7 @@ def __init__( self.tags = None -class Key(Resource): +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. @@ -664,12 +610,12 @@ class Key(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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", "RSA-HSM". + "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 @@ -677,7 +623,7 @@ class Key(Resource): :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", "P-256K". + 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 @@ -692,30 +638,30 @@ class Key(Resource): """ _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'}, + "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__( @@ -734,7 +680,7 @@ def __init__( :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", "RSA-HSM". + "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 @@ -742,7 +688,7 @@ def __init__( :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", "P-256K". + 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 @@ -752,7 +698,7 @@ def __init__( input. Omitted if empty. :paramtype release_policy: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyReleasePolicy """ - super(Key, self).__init__(**kwargs) + super().__init__(**kwargs) self.attributes = attributes self.kty = kty self.key_ops = key_ops @@ -764,7 +710,7 @@ def __init__( self.release_policy = release_policy -class KeyAttributes(msrest.serialization.Model): +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. @@ -772,17 +718,17 @@ class KeyAttributes(msrest.serialization.Model): :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: long + :vartype not_before: int :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: long + :vartype expires: int :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: long + :vartype created: int :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: long + :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", + values are: "Purgeable", "Recoverable+Purgeable", "Recoverable", and "Recoverable+ProtectedSubscription". :vartype recovery_level: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletionRecoveryLevel @@ -791,19 +737,19 @@ class KeyAttributes(msrest.serialization.Model): """ _validation = { - 'created': {'readonly': True}, - 'updated': {'readonly': True}, - 'recovery_level': {'readonly': True}, + "created": {"readonly": True}, + "updated": {"readonly": True}, + "recovery_level": {"readonly": True}, } _attribute_map = { - 'enabled': {'key': 'enabled', 'type': 'bool'}, - 'not_before': {'key': 'nbf', 'type': 'long'}, - 'expires': {'key': 'exp', 'type': 'long'}, - 'created': {'key': 'created', 'type': 'long'}, - 'updated': {'key': 'updated', 'type': 'long'}, - 'recovery_level': {'key': 'recoveryLevel', 'type': 'str'}, - 'exportable': {'key': 'exportable', 'type': 'bool'}, + "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__( @@ -819,13 +765,13 @@ def __init__( :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: long + :paramtype not_before: int :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :paramtype expires: long + :paramtype expires: int :keyword exportable: Indicates if the private key can be exported. :paramtype exportable: bool """ - super(KeyAttributes, self).__init__(**kwargs) + super().__init__(**kwargs) self.enabled = enabled self.not_before = not_before self.expires = expires @@ -835,45 +781,39 @@ def __init__( self.exportable = exportable -class KeyCreateParameters(msrest.serialization.Model): +class KeyCreateParameters(_serialization.Model): """The parameters used to create a key. All required parameters must be populated in order to send to Azure. - :ivar tags: A set of tags. The tags that will be assigned to the key. + :ivar tags: The tags that will be assigned to the key. :vartype tags: dict[str, str] - :ivar properties: Required. The properties of the key to be created. + :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}, + "properties": {"required": True}, } _attribute_map = { - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'KeyProperties'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "KeyProperties"}, } - def __init__( - self, - *, - properties: "_models.KeyProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs - ): + def __init__(self, *, properties: "_models.KeyProperties", tags: Optional[Dict[str, str]] = None, **kwargs): """ - :keyword tags: A set of tags. The tags that will be assigned to the key. + :keyword tags: The tags that will be assigned to the key. :paramtype tags: dict[str, str] - :keyword properties: Required. The properties of the key to be created. + :keyword properties: The properties of the key to be created. Required. :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyProperties """ - super(KeyCreateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class KeyListResult(msrest.serialization.Model): +class KeyListResult(_serialization.Model): """The page of keys. :ivar value: The key resources. @@ -883,29 +823,23 @@ class KeyListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Key]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Key"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(KeyListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class KeyProperties(msrest.serialization.Model): +class KeyProperties(_serialization.Model): """The properties of the key. Variables are only populated by the server, and will be ignored when sending a request. @@ -913,7 +847,7 @@ class KeyProperties(msrest.serialization.Model): :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", "RSA-HSM". + "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 @@ -921,7 +855,7 @@ class KeyProperties(msrest.serialization.Model): :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", "P-256K". + 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 @@ -936,20 +870,20 @@ class KeyProperties(msrest.serialization.Model): """ _validation = { - 'key_uri': {'readonly': True}, - 'key_uri_with_version': {'readonly': True}, + "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'}, + "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__( @@ -968,7 +902,7 @@ def __init__( :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", "RSA-HSM". + "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 @@ -976,7 +910,7 @@ def __init__( :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", "P-256K". + 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 @@ -986,7 +920,7 @@ def __init__( input. Omitted if empty. :paramtype release_policy: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyReleasePolicy """ - super(KeyProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.attributes = attributes self.kty = kty self.key_ops = key_ops @@ -998,7 +932,7 @@ def __init__( self.release_policy = release_policy -class KeyReleasePolicy(msrest.serialization.Model): +class KeyReleasePolicy(_serialization.Model): """KeyReleasePolicy. :ivar content_type: Content type and version of key release policy. @@ -1008,16 +942,12 @@ class KeyReleasePolicy(msrest.serialization.Model): """ _attribute_map = { - 'content_type': {'key': 'contentType', 'type': 'str'}, - 'data': {'key': 'data', 'type': 'base64'}, + "content_type": {"key": "contentType", "type": "str"}, + "data": {"key": "data", "type": "base64"}, } def __init__( - self, - *, - content_type: Optional[str] = "application/json; charset=utf-8", - data: Optional[bytes] = None, - **kwargs + self, *, content_type: str = "application/json; charset=utf-8", data: Optional[bytes] = None, **kwargs ): """ :keyword content_type: Content type and version of key release policy. @@ -1025,54 +955,49 @@ def __init__( :keyword data: Blob encoding the policy rules under which the key can be released. :paramtype data: bytes """ - super(KeyReleasePolicy, self).__init__(**kwargs) + super().__init__(**kwargs) self.content_type = content_type self.data = data -class KeyRotationPolicyAttributes(msrest.serialization.Model): +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: long + :vartype created: int :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: long + :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}, + "created": {"readonly": True}, + "updated": {"readonly": True}, } _attribute_map = { - 'created': {'key': 'created', 'type': 'long'}, - 'updated': {'key': 'updated', 'type': 'long'}, - 'expiry_time': {'key': 'expiryTime', 'type': 'str'}, + "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 - ): + def __init__(self, *, expiry_time: Optional[str] = None, **kwargs): """ :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(KeyRotationPolicyAttributes, self).__init__(**kwargs) + super().__init__(**kwargs) self.created = None self.updated = None self.expiry_time = expiry_time -class LifetimeAction(msrest.serialization.Model): +class LifetimeAction(_serialization.Model): """LifetimeAction. :ivar trigger: The trigger of key rotation policy lifetimeAction. @@ -1082,16 +1007,12 @@ class LifetimeAction(msrest.serialization.Model): """ _attribute_map = { - 'trigger': {'key': 'trigger', 'type': 'Trigger'}, - 'action': {'key': 'action', 'type': 'Action'}, + "trigger": {"key": "trigger", "type": "Trigger"}, + "action": {"key": "action", "type": "Action"}, } def __init__( - self, - *, - trigger: Optional["_models.Trigger"] = None, - action: Optional["_models.Action"] = None, - **kwargs + self, *, trigger: Optional["_models.Trigger"] = None, action: Optional["_models.Action"] = None, **kwargs ): """ :keyword trigger: The trigger of key rotation policy lifetimeAction. @@ -1099,12 +1020,12 @@ def __init__( :keyword action: The action of key rotation policy lifetimeAction. :paramtype action: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Action """ - super(LifetimeAction, self).__init__(**kwargs) + super().__init__(**kwargs) self.trigger = trigger self.action = action -class LogSpecification(msrest.serialization.Model): +class LogSpecification(_serialization.Model): """Log specification of operation. :ivar name: Name of log specification. @@ -1116,9 +1037,9 @@ class LogSpecification(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'blob_duration': {'key': 'blobDuration', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "blob_duration": {"key": "blobDuration", "type": "str"}, } def __init__( @@ -1137,13 +1058,13 @@ def __init__( :keyword blob_duration: Blob duration of specification. :paramtype blob_duration: str """ - super(LogSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.blob_duration = blob_duration -class ManagedHsmResource(msrest.serialization.Model): +class ManagedHsmResource(_serialization.Model): """Managed HSM resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -1158,7 +1079,7 @@ class ManagedHsmResource(msrest.serialization.Model): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -1166,20 +1087,20 @@ class ManagedHsmResource(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'system_data': {'readonly': True}, + "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'}, + "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__( @@ -1195,10 +1116,10 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :keyword tags: Resource tags. :paramtype tags: dict[str, str] """ - super(ManagedHsmResource, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -1223,7 +1144,7 @@ class ManagedHsm(ManagedHsmResource): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -1233,21 +1154,21 @@ class ManagedHsm(ManagedHsmResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'system_data': {'readonly': True}, + "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'}, + "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__( @@ -1264,16 +1185,16 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :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(ManagedHsm, self).__init__(location=location, sku=sku, tags=tags, **kwargs) + super().__init__(location=location, sku=sku, tags=tags, **kwargs) self.properties = properties -class ManagedHsmError(msrest.serialization.Model): +class ManagedHsmError(_serialization.Model): """The error exception. Variables are only populated by the server, and will be ignored when sending a request. @@ -1283,24 +1204,20 @@ class ManagedHsmError(msrest.serialization.Model): """ _validation = { - 'error': {'readonly': True}, + "error": {"readonly": True}, } _attribute_map = { - 'error': {'key': 'error', 'type': 'Error'}, + "error": {"key": "error", "type": "Error"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(ManagedHsmError, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.error = None -class ManagedHsmListResult(msrest.serialization.Model): +class ManagedHsmListResult(_serialization.Model): """List of managed HSM Pools. :ivar value: The list of managed HSM Pools. @@ -1310,16 +1227,12 @@ class ManagedHsmListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[ManagedHsm]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.ManagedHsm"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of managed HSM Pools. @@ -1327,12 +1240,12 @@ def __init__( :keyword next_link: The URL to get the next set of managed HSM Pools. :paramtype next_link: str """ - super(ManagedHsmListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class ManagedHsmProperties(msrest.serialization.Model): +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. @@ -1359,12 +1272,12 @@ class ManagedHsmProperties(msrest.serialization.Model): 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", "default". + 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", "Restoring". + "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 @@ -1375,7 +1288,7 @@ class ManagedHsmProperties(msrest.serialization.Model): :vartype private_endpoint_connections: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnectionItem] :ivar public_network_access: Control permission for data plane traffic coming from public - networks while private endpoint is enabled. Known values are: "Enabled", "Disabled". + networks while private endpoint is enabled. 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. @@ -1383,27 +1296,30 @@ class ManagedHsmProperties(msrest.serialization.Model): """ _validation = { - 'hsm_uri': {'readonly': True}, - 'status_message': {'readonly': True}, - 'provisioning_state': {'readonly': True}, - 'private_endpoint_connections': {'readonly': True}, - 'scheduled_purge_date': {'readonly': True}, + "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'}, + "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__( @@ -1411,9 +1327,9 @@ def __init__( *, tenant_id: Optional[str] = None, initial_admin_object_ids: Optional[List[str]] = None, - enable_soft_delete: Optional[bool] = True, - soft_delete_retention_in_days: Optional[int] = 90, - enable_purge_protection: Optional[bool] = True, + 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: Optional[Union[str, "_models.PublicNetworkAccess"]] = None, @@ -1441,17 +1357,17 @@ def __init__( 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", "default". + 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 for data plane traffic coming from public - networks while private endpoint is enabled. Known values are: "Enabled", "Disabled". + networks while private endpoint is enabled. Known values are: "Enabled" and "Disabled". :paramtype public_network_access: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.PublicNetworkAccess """ - super(ManagedHsmProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.initial_admin_object_ids = initial_admin_object_ids self.hsm_uri = None @@ -1467,48 +1383,48 @@ def __init__( self.scheduled_purge_date = None -class ManagedHsmSku(msrest.serialization.Model): +class ManagedHsmSku(_serialization.Model): """SKU details. All required parameters must be populated in order to send to Azure. - :ivar family: Required. SKU Family of the managed HSM Pool. Known values are: "B". + :ivar family: SKU Family of the managed HSM Pool. Required. "B" :vartype family: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSkuFamily - :ivar name: Required. SKU of the managed HSM Pool. Known values are: "Standard_B1", + :ivar name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1" and "Custom_B32". :vartype name: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSkuName """ _validation = { - 'family': {'required': True}, - 'name': {'required': True}, + "family": {"required": True}, + "name": {"required": True}, } _attribute_map = { - 'family': {'key': 'family', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, + "family": {"key": "family", "type": "str"}, + "name": {"key": "name", "type": "str"}, } def __init__( self, *, - family: Union[str, "_models.ManagedHsmSkuFamily"] = "B", + family: Union[str, "_models.ManagedHsmSkuFamily"], name: Union[str, "_models.ManagedHsmSkuName"], **kwargs ): """ - :keyword family: Required. SKU Family of the managed HSM Pool. Known values are: "B". + :keyword family: SKU Family of the managed HSM Pool. Required. "B" :paramtype family: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSkuFamily - :keyword name: Required. SKU of the managed HSM Pool. Known values are: "Standard_B1", + :keyword name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1" and "Custom_B32". :paramtype name: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSkuName """ - super(ManagedHsmSku, self).__init__(**kwargs) + super().__init__(**kwargs) self.family = family self.name = name -class MetricSpecification(msrest.serialization.Model): +class MetricSpecification(_serialization.Model): # pylint: disable=too-many-instance-attributes """Metric specification of operation. :ivar name: Name of metric specification. @@ -1537,17 +1453,17 @@ class MetricSpecification(msrest.serialization.Model): """ _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'}, + "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__( @@ -1592,7 +1508,7 @@ def __init__( :keyword internal_metric_name: The internal metric name. :paramtype internal_metric_name: str """ - super(MetricSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.display_description = display_description @@ -1606,50 +1522,45 @@ def __init__( self.internal_metric_name = internal_metric_name -class MHSMIPRule(msrest.serialization.Model): +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 Azure. - :ivar value: Required. 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). + :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}, + "value": {"required": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, + "value": {"key": "value", "type": "str"}, } - def __init__( - self, - *, - value: str, - **kwargs - ): + def __init__(self, *, value: str, **kwargs): """ - :keyword value: Required. 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). + :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(MHSMIPRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class MHSMNetworkRuleSet(msrest.serialization.Model): +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", + '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", "Deny". + "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. @@ -1660,10 +1571,10 @@ class MHSMNetworkRuleSet(msrest.serialization.Model): """ _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]'}, + "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__( @@ -1677,13 +1588,13 @@ 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", + '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", "Deny". + 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. @@ -1692,14 +1603,14 @@ def __init__( :paramtype virtual_network_rules: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMVirtualNetworkRule] """ - super(MHSMNetworkRuleSet, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class MHSMPrivateEndpoint(_serialization.Model): """Private endpoint object properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -1709,24 +1620,20 @@ class MHSMPrivateEndpoint(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, + "id": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(MHSMPrivateEndpoint, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None -class MHSMPrivateEndpointConnection(ManagedHsmResource): +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. @@ -1741,7 +1648,7 @@ class MHSMPrivateEndpointConnection(ManagedHsmResource): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -1754,30 +1661,33 @@ class MHSMPrivateEndpointConnection(ManagedHsmResource): :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", "Disconnected". + 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}, + "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'}, + "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__( @@ -1797,7 +1707,7 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :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 @@ -1808,18 +1718,18 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnectionProvisioningState """ - super(MHSMPrivateEndpointConnection, self).__init__(location=location, sku=sku, tags=tags, **kwargs) + 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(msrest.serialization.Model): +class MHSMPrivateEndpointConnectionItem(_serialization.Model): """Private endpoint connection item. :ivar id: Id of private endpoint connection. @@ -1832,23 +1742,26 @@ class MHSMPrivateEndpointConnectionItem(msrest.serialization.Model): :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", "Disconnected". + 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'}, + "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, + 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, @@ -1867,11 +1780,11 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnectionProvisioningState """ - super(MHSMPrivateEndpointConnectionItem, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id self.etag = etag self.private_endpoint = private_endpoint @@ -1879,7 +1792,7 @@ def __init__( self.provisioning_state = provisioning_state -class MHSMPrivateEndpointConnectionsListResult(msrest.serialization.Model): +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. @@ -1890,8 +1803,8 @@ class MHSMPrivateEndpointConnectionsListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[MHSMPrivateEndpointConnection]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[MHSMPrivateEndpointConnection]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( @@ -1908,7 +1821,7 @@ def __init__( :keyword next_link: The URL to get the next set of managed HSM Pools. :paramtype next_link: str """ - super(MHSMPrivateEndpointConnectionsListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link @@ -1928,7 +1841,7 @@ class MHSMPrivateLinkResource(ManagedHsmResource): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -1942,25 +1855,25 @@ class MHSMPrivateLinkResource(ManagedHsmResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'system_data': {'readonly': True}, - 'group_id': {'readonly': True}, - 'required_members': {'readonly': True}, + "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]'}, + "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__( @@ -1977,18 +1890,18 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :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(MHSMPrivateLinkResource, self).__init__(location=location, sku=sku, tags=tags, **kwargs) + 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(msrest.serialization.Model): +class MHSMPrivateLinkResourceListResult(_serialization.Model): """A list of private link resources. :ivar value: Array of private link resources. @@ -1996,42 +1909,37 @@ class MHSMPrivateLinkResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[MHSMPrivateLinkResource]'}, + "value": {"key": "value", "type": "[MHSMPrivateLinkResource]"}, } - def __init__( - self, - *, - value: Optional[List["_models.MHSMPrivateLinkResource"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.MHSMPrivateLinkResource"]] = None, **kwargs): """ :keyword value: Array of private link resources. :paramtype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateLinkResource] """ - super(MHSMPrivateLinkResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class MHSMPrivateLinkServiceConnectionState(msrest.serialization.Model): +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", "Disconnected". + 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. Known values are: "None". + 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'}, + "status": {"key": "status", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "actions_required": {"key": "actionsRequired", "type": "str"}, } def __init__( @@ -2044,66 +1952,63 @@ 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", "Disconnected". + 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. Known values are: "None". + updates on the consumer. "None" :paramtype actions_required: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.ActionsRequired """ - super(MHSMPrivateLinkServiceConnectionState, self).__init__(**kwargs) + super().__init__(**kwargs) self.status = status self.description = description self.actions_required = actions_required -class MHSMVirtualNetworkRule(msrest.serialization.Model): +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 Azure. - :ivar id: Required. Full resource id of a vnet subnet, such as + :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}, + "id": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - *, - id: str, - **kwargs - ): + def __init__(self, *, id: str, **kwargs): # pylint: disable=redefined-builtin """ - :keyword id: Required. Full resource id of a vnet subnet, such as + :keyword id: Full resource id of a vnet subnet, such as '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. + Required. :paramtype id: str """ - super(MHSMVirtualNetworkRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id -class NetworkRuleSet(msrest.serialization.Model): +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", + '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", "Deny". + "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. @@ -2114,10 +2019,10 @@ class NetworkRuleSet(msrest.serialization.Model): """ _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]'}, + "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__( @@ -2131,13 +2036,13 @@ 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", + '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", "Deny". + 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. @@ -2146,14 +2051,14 @@ def __init__( :paramtype virtual_network_rules: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.VirtualNetworkRule] """ - super(NetworkRuleSet, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class Operation(_serialization.Model): """Key Vault REST API operation definition. :ivar name: Operation name: {provider}/{resource}/{operation}. @@ -2170,11 +2075,11 @@ class Operation(msrest.serialization.Model): """ _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'}, + "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__( @@ -2200,7 +2105,7 @@ def __init__( :paramtype service_specification: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ServiceSpecification """ - super(Operation, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display = display self.origin = origin @@ -2208,7 +2113,7 @@ def __init__( self.service_specification = service_specification -class OperationDisplay(msrest.serialization.Model): +class OperationDisplay(_serialization.Model): """Display metadata associated with the operation. :ivar provider: Service provider: Microsoft Key Vault. @@ -2222,10 +2127,10 @@ class OperationDisplay(msrest.serialization.Model): """ _attribute_map = { - 'provider': {'key': 'provider', 'type': 'str'}, - 'resource': {'key': 'resource', 'type': 'str'}, - 'operation': {'key': 'operation', 'type': 'str'}, - 'description': {'key': 'description', 'type': 'str'}, + "provider": {"key": "provider", "type": "str"}, + "resource": {"key": "resource", "type": "str"}, + "operation": {"key": "operation", "type": "str"}, + "description": {"key": "description", "type": "str"}, } def __init__( @@ -2247,14 +2152,14 @@ def __init__( :keyword description: Description of operation. :paramtype description: str """ - super(OperationDisplay, self).__init__(**kwargs) + super().__init__(**kwargs) self.provider = provider self.resource = resource self.operation = operation self.description = description -class OperationListResult(msrest.serialization.Model): +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. @@ -2264,29 +2169,23 @@ class OperationListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Operation]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(OperationListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class Permissions(msrest.serialization.Model): +class Permissions(_serialization.Model): """Permissions the identity has for keys, secrets, certificates and storage. :ivar keys: Permissions to keys. @@ -2303,10 +2202,10 @@ class Permissions(msrest.serialization.Model): """ _attribute_map = { - 'keys': {'key': 'keys', 'type': '[str]'}, - 'secrets': {'key': 'secrets', 'type': '[str]'}, - 'certificates': {'key': 'certificates', 'type': '[str]'}, - 'storage': {'key': 'storage', 'type': '[str]'}, + "keys": {"key": "keys", "type": "[str]"}, + "secrets": {"key": "secrets", "type": "[str]"}, + "certificates": {"key": "certificates", "type": "[str]"}, + "storage": {"key": "storage", "type": "[str]"}, } def __init__( @@ -2331,14 +2230,14 @@ def __init__( :paramtype storage: list[str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.StoragePermissions] """ - super(Permissions, self).__init__(**kwargs) + super().__init__(**kwargs) self.keys = keys self.secrets = secrets self.certificates = certificates self.storage = storage -class PrivateEndpoint(msrest.serialization.Model): +class PrivateEndpoint(_serialization.Model): """Private endpoint object properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -2348,20 +2247,16 @@ class PrivateEndpoint(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, + "id": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(PrivateEndpoint, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None @@ -2378,7 +2273,7 @@ class PrivateEndpointConnection(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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 @@ -2388,29 +2283,32 @@ class PrivateEndpointConnection(Resource): :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", "Disconnected". + 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}, + "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'}, + "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__( @@ -2431,18 +2329,18 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnectionProvisioningState """ - super(PrivateEndpointConnection, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class PrivateEndpointConnectionItem(_serialization.Model): """Private endpoint connection item. :ivar id: Id of private endpoint connection. @@ -2455,23 +2353,26 @@ class PrivateEndpointConnectionItem(msrest.serialization.Model): :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", "Disconnected". + 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'}, + "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, + 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, @@ -2489,11 +2390,11 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnectionProvisioningState """ - super(PrivateEndpointConnectionItem, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id self.etag = etag self.private_endpoint = private_endpoint @@ -2501,7 +2402,7 @@ def __init__( self.provisioning_state = provisioning_state -class PrivateEndpointConnectionListResult(msrest.serialization.Model): +class PrivateEndpointConnectionListResult(_serialization.Model): """List of private endpoint connections. :ivar value: The list of private endpoint connections. @@ -2511,8 +2412,8 @@ class PrivateEndpointConnectionListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[PrivateEndpointConnection]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[PrivateEndpointConnection]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( @@ -2529,7 +2430,7 @@ def __init__( :keyword next_link: The URL to get the next set of private endpoint connections. :paramtype next_link: str """ - super(PrivateEndpointConnectionListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link @@ -2547,7 +2448,7 @@ class PrivateLinkResource(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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 @@ -2558,43 +2459,38 @@ class PrivateLinkResource(Resource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'location': {'readonly': True}, - 'tags': {'readonly': True}, - 'group_id': {'readonly': True}, - 'required_members': {'readonly': True}, + "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]'}, + "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 - ): + def __init__(self, *, required_zone_names: Optional[List[str]] = None, **kwargs): """ :keyword required_zone_names: Required DNS zone names of the the private link resource. :paramtype required_zone_names: list[str] """ - super(PrivateLinkResource, self).__init__(**kwargs) + super().__init__(**kwargs) self.group_id = None self.required_members = None self.required_zone_names = required_zone_names -class PrivateLinkResourceListResult(msrest.serialization.Model): +class PrivateLinkResourceListResult(_serialization.Model): """A list of private link resources. :ivar value: Array of private link resources. @@ -2602,42 +2498,37 @@ class PrivateLinkResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[PrivateLinkResource]'}, + "value": {"key": "value", "type": "[PrivateLinkResource]"}, } - def __init__( - self, - *, - value: Optional[List["_models.PrivateLinkResource"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs): """ :keyword value: Array of private link resources. :paramtype value: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateLinkResource] """ - super(PrivateLinkResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class PrivateLinkServiceConnectionState(msrest.serialization.Model): +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", "Disconnected". + 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. Known values are: "None". + 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'}, + "status": {"key": "status", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "actions_required": {"key": "actionsRequired", "type": "str"}, } def __init__( @@ -2650,23 +2541,23 @@ 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", "Disconnected". + 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. Known values are: "None". + updates on the consumer. "None" :paramtype actions_required: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.ActionsRequired """ - super(PrivateLinkServiceConnectionState, self).__init__(**kwargs) + super().__init__(**kwargs) self.status = status self.description = description self.actions_required = actions_required -class ResourceListResult(msrest.serialization.Model): +class ResourceListResult(_serialization.Model): """List of vault resources. :ivar value: The list of vault resources. @@ -2676,29 +2567,23 @@ class ResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Resource]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Resource"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(ResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class RotationPolicy(msrest.serialization.Model): +class RotationPolicy(_serialization.Model): """RotationPolicy. :ivar attributes: The attributes of key rotation policy. @@ -2709,8 +2594,8 @@ class RotationPolicy(msrest.serialization.Model): """ _attribute_map = { - 'attributes': {'key': 'attributes', 'type': 'KeyRotationPolicyAttributes'}, - 'lifetime_actions': {'key': 'lifetimeActions', 'type': '[LifetimeAction]'}, + "attributes": {"key": "attributes", "type": "KeyRotationPolicyAttributes"}, + "lifetime_actions": {"key": "lifetimeActions", "type": "[LifetimeAction]"}, } def __init__( @@ -2728,7 +2613,7 @@ def __init__( :paramtype lifetime_actions: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.LifetimeAction] """ - super(RotationPolicy, self).__init__(**kwargs) + super().__init__(**kwargs) self.attributes = attributes self.lifetime_actions = lifetime_actions @@ -2748,41 +2633,36 @@ class Secret(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :ivar tags: Tags assigned to the key vault resource. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the secret. + :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}, + "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'}, + "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 - ): + def __init__(self, *, properties: "_models.SecretProperties", **kwargs): """ - :keyword properties: Required. Properties of the secret. + :keyword properties: Properties of the secret. Required. :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretProperties """ - super(Secret, self).__init__(**kwargs) + super().__init__(**kwargs) self.properties = properties @@ -2804,16 +2684,16 @@ class SecretAttributes(Attributes): """ _validation = { - 'created': {'readonly': True}, - 'updated': {'readonly': True}, + "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'}, + "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__( @@ -2832,48 +2712,42 @@ def __init__( :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. :paramtype expires: ~datetime.datetime """ - super(SecretAttributes, self).__init__(enabled=enabled, not_before=not_before, expires=expires, **kwargs) + super().__init__(enabled=enabled, not_before=not_before, expires=expires, **kwargs) -class SecretCreateOrUpdateParameters(msrest.serialization.Model): +class SecretCreateOrUpdateParameters(_serialization.Model): """Parameters for creating or updating a secret. All required parameters must be populated in order to send to Azure. - :ivar tags: A set of tags. The tags that will be assigned to the secret. + :ivar tags: The tags that will be assigned to the secret. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the secret. + :ivar properties: Properties of the secret. Required. :vartype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretProperties """ _validation = { - 'properties': {'required': True}, + "properties": {"required": True}, } _attribute_map = { - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'SecretProperties'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "SecretProperties"}, } - def __init__( - self, - *, - properties: "_models.SecretProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs - ): + def __init__(self, *, properties: "_models.SecretProperties", tags: Optional[Dict[str, str]] = None, **kwargs): """ - :keyword tags: A set of tags. The tags that will be assigned to the secret. + :keyword tags: The tags that will be assigned to the secret. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the secret. + :keyword properties: Properties of the secret. Required. :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretProperties """ - super(SecretCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class SecretListResult(msrest.serialization.Model): +class SecretListResult(_serialization.Model): """List of secrets. :ivar value: The list of secrets. @@ -2883,40 +2757,34 @@ class SecretListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Secret]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Secret"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(SecretListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class SecretPatchParameters(msrest.serialization.Model): +class SecretPatchParameters(_serialization.Model): """Parameters for patching a secret. - :ivar tags: A set of tags. The tags that will be assigned to the 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'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "SecretPatchProperties"}, } def __init__( @@ -2927,17 +2795,17 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. The tags that will be assigned to the secret. + :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(SecretPatchParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class SecretPatchProperties(msrest.serialization.Model): +class SecretPatchProperties(_serialization.Model): """Properties of the secret. :ivar value: The value of the secret. @@ -2949,9 +2817,9 @@ class SecretPatchProperties(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, - 'content_type': {'key': 'contentType', 'type': 'str'}, - 'attributes': {'key': 'attributes', 'type': 'SecretAttributes'}, + "value": {"key": "value", "type": "str"}, + "content_type": {"key": "contentType", "type": "str"}, + "attributes": {"key": "attributes", "type": "SecretAttributes"}, } def __init__( @@ -2970,13 +2838,13 @@ def __init__( :keyword attributes: The attributes of the secret. :paramtype attributes: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretAttributes """ - super(SecretPatchProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.content_type = content_type self.attributes = attributes -class SecretProperties(msrest.serialization.Model): +class SecretProperties(_serialization.Model): """Properties of the secret. Variables are only populated by the server, and will be ignored when sending a request. @@ -2996,16 +2864,16 @@ class SecretProperties(msrest.serialization.Model): """ _validation = { - 'secret_uri': {'readonly': True}, - 'secret_uri_with_version': {'readonly': True}, + "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'}, + "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__( @@ -3026,7 +2894,7 @@ def __init__( :keyword attributes: The attributes of the secret. :paramtype attributes: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretAttributes """ - super(SecretProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.content_type = content_type self.attributes = attributes @@ -3034,7 +2902,7 @@ def __init__( self.secret_uri_with_version = None -class ServiceSpecification(msrest.serialization.Model): +class ServiceSpecification(_serialization.Model): """One property of operation, include log specifications. :ivar log_specifications: Log specifications of operation. @@ -3046,8 +2914,8 @@ class ServiceSpecification(msrest.serialization.Model): """ _attribute_map = { - 'log_specifications': {'key': 'logSpecifications', 'type': '[LogSpecification]'}, - 'metric_specifications': {'key': 'metricSpecifications', 'type': '[MetricSpecification]'}, + "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, + "metric_specifications": {"key": "metricSpecifications", "type": "[MetricSpecification]"}, } def __init__( @@ -3065,66 +2933,60 @@ def __init__( :paramtype metric_specifications: list[~azure.mgmt.keyvault.v2021_06_01_preview.models.MetricSpecification] """ - super(ServiceSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.log_specifications = log_specifications self.metric_specifications = metric_specifications -class Sku(msrest.serialization.Model): +class Sku(_serialization.Model): """SKU details. All required parameters must be populated in order to send to Azure. - :ivar family: Required. SKU family name. Known values are: "A". + :ivar family: SKU family name. Required. "A" :vartype family: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.SkuFamily - :ivar name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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}, + "family": {"required": True}, + "name": {"required": True}, } _attribute_map = { - 'family': {'key': 'family', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, + "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 - ): + def __init__(self, *, family: Union[str, "_models.SkuFamily"], name: Union[str, "_models.SkuName"], **kwargs): """ - :keyword family: Required. SKU family name. Known values are: "A". + :keyword family: SKU family name. Required. "A" :paramtype family: str or ~azure.mgmt.keyvault.v2021_06_01_preview.models.SkuFamily - :keyword name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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(Sku, self).__init__(**kwargs) + super().__init__(**kwargs) self.family = family self.name = name -class SystemData(msrest.serialization.Model): +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", "Key". + 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", "Key". + 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). @@ -3132,12 +2994,12 @@ class SystemData(msrest.serialization.Model): """ _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'}, + "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__( @@ -3155,20 +3017,20 @@ def __init__( :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", "Key". + 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", "Key". + 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(SystemData, self).__init__(**kwargs) + super().__init__(**kwargs) self.created_by = created_by self.created_by_type = created_by_type self.created_at = created_at @@ -3177,7 +3039,7 @@ def __init__( self.last_modified_at = last_modified_at -class Trigger(msrest.serialization.Model): +class Trigger(_serialization.Model): """Trigger. :ivar time_after_create: The time duration after key creation to rotate the key. It only @@ -3189,17 +3051,11 @@ class Trigger(msrest.serialization.Model): """ _attribute_map = { - 'time_after_create': {'key': 'timeAfterCreate', 'type': 'str'}, - 'time_before_expiry': {'key': 'timeBeforeExpiry', 'type': 'str'}, + "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 - ): + def __init__(self, *, time_after_create: Optional[str] = None, time_before_expiry: Optional[str] = None, **kwargs): """ :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'. @@ -3208,12 +3064,12 @@ def __init__( be in ISO 8601 duration format. Eg: 'P90D', 'P1Y'. :paramtype time_before_expiry: str """ - super(Trigger, self).__init__(**kwargs) + super().__init__(**kwargs) self.time_after_create = time_after_create self.time_before_expiry = time_before_expiry -class Vault(msrest.serialization.Model): +class Vault(_serialization.Model): """Resource information with extended details. Variables are only populated by the server, and will be ignored when sending a request. @@ -3228,30 +3084,30 @@ class Vault(msrest.serialization.Model): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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: Required. Properties of the vault. + :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}, + "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'}, + "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__( @@ -3265,12 +3121,12 @@ def __init__( """ :keyword location: Azure location of the key vault resource. :paramtype location: str - :keyword tags: A set of tags. Tags assigned to the key vault resource. + :keyword tags: Tags assigned to the key vault resource. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultProperties """ - super(Vault, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -3280,7 +3136,7 @@ def __init__( self.properties = properties -class VaultAccessPolicyParameters(msrest.serialization.Model): +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. @@ -3295,39 +3151,34 @@ class VaultAccessPolicyParameters(msrest.serialization.Model): :vartype type: str :ivar location: The resource type of the access policy. :vartype location: str - :ivar properties: Required. Properties of the access policy. + :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}, + "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'}, + "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 - ): + def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs): """ - :keyword properties: Required. Properties of the access policy. + :keyword properties: Properties of the access policy. Required. :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyProperties """ - super(VaultAccessPolicyParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -3335,129 +3186,114 @@ def __init__( self.properties = properties -class VaultAccessPolicyProperties(msrest.serialization.Model): +class VaultAccessPolicyProperties(_serialization.Model): """Properties of the vault access policy. All required parameters must be populated in order to send to Azure. - :ivar access_policies: Required. 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. + :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}, + "access_policies": {"required": True}, } _attribute_map = { - 'access_policies': {'key': 'accessPolicies', 'type': '[AccessPolicyEntry]'}, + "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, } - def __init__( - self, - *, - access_policies: List["_models.AccessPolicyEntry"], - **kwargs - ): + def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwargs): """ - :keyword access_policies: Required. 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. + :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(VaultAccessPolicyProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.access_policies = access_policies -class VaultCheckNameAvailabilityParameters(msrest.serialization.Model): +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 Azure. - :ivar name: Required. The vault name. + :ivar name: The vault name. Required. :vartype name: str - :ivar type: The type of resource, Microsoft.KeyVault/vaults. Has constant value: + :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}, + "name": {"required": True}, + "type": {"required": True, "constant": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, } type = "Microsoft.KeyVault/vaults" - def __init__( - self, - *, - name: str, - **kwargs - ): + def __init__(self, *, name: str, **kwargs): """ - :keyword name: Required. The vault name. + :keyword name: The vault name. Required. :paramtype name: str """ - super(VaultCheckNameAvailabilityParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name -class VaultCreateOrUpdateParameters(msrest.serialization.Model): +class VaultCreateOrUpdateParameters(_serialization.Model): """Parameters for creating or updating a vault. All required parameters must be populated in order to send to Azure. - :ivar location: Required. The supported Azure location where the key vault should be created. + :ivar location: The supported Azure location where the key vault should be created. Required. :vartype location: str - :ivar tags: A set of tags. The tags that will be assigned to the key vault. + :ivar tags: The tags that will be assigned to the key vault. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the vault. + :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}, + "location": {"required": True}, + "properties": {"required": True}, } _attribute_map = { - 'location': {'key': 'location', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'VaultProperties'}, + "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 + self, *, location: str, properties: "_models.VaultProperties", tags: Optional[Dict[str, str]] = None, **kwargs ): """ - :keyword location: Required. The supported Azure location where the key vault should be - created. + :keyword location: The supported Azure location where the key vault should be created. + Required. :paramtype location: str - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :keyword tags: The tags that will be assigned to the key vault. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultProperties """ - super(VaultCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.location = location self.tags = tags self.properties = properties -class VaultListResult(msrest.serialization.Model): +class VaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of vaults. @@ -3467,40 +3303,34 @@ class VaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Vault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Vault"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(VaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class VaultPatchParameters(msrest.serialization.Model): +class VaultPatchParameters(_serialization.Model): """Parameters for creating or updating a vault. - :ivar tags: A set of tags. The tags that will be assigned to the key 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'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "VaultPatchProperties"}, } def __init__( @@ -3511,17 +3341,17 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :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(VaultPatchParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class VaultPatchProperties(msrest.serialization.Model): +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 @@ -3555,7 +3385,7 @@ class VaultPatchProperties(msrest.serialization.Model): :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", "default". + 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 @@ -3574,19 +3404,19 @@ class VaultPatchProperties(msrest.serialization.Model): """ _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'}, + "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__( @@ -3640,7 +3470,7 @@ def __init__( <=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", "default". + 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 @@ -3657,7 +3487,7 @@ def __init__( meaning that even if the firewall rules are present we will not honor the rules. :paramtype public_network_access: str """ - super(VaultPatchProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies @@ -3673,17 +3503,17 @@ def __init__( self.public_network_access = public_network_access -class VaultProperties(msrest.serialization.Model): +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 Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :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 @@ -3719,7 +3549,7 @@ class VaultProperties(msrest.serialization.Model): 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", "default". + 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 @@ -3730,7 +3560,7 @@ class VaultProperties(msrest.serialization.Model): :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", + :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 @@ -3746,30 +3576,33 @@ class VaultProperties(msrest.serialization.Model): """ _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'}, + "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__( @@ -3782,21 +3615,21 @@ def __init__( 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] = True, - soft_delete_retention_in_days: Optional[int] = 90, - enable_rbac_authorization: Optional[bool] = False, + 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: Optional[str] = "enabled", + public_network_access: str = "enabled", **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :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 @@ -3831,7 +3664,7 @@ def __init__( 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", "default". + 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 @@ -3842,7 +3675,7 @@ def __init__( :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", + :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 @@ -3852,7 +3685,7 @@ def __init__( meaning that even if the firewall rules are present we will not honor the rules. :paramtype public_network_access: str """ - super(VaultProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies @@ -3872,13 +3705,14 @@ def __init__( self.public_network_access = public_network_access -class VirtualNetworkRule(msrest.serialization.Model): +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 Azure. - :ivar id: Required. Full resource id of a vnet subnet, such as + :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. @@ -3886,29 +3720,30 @@ class VirtualNetworkRule(msrest.serialization.Model): """ _validation = { - 'id': {'required': True}, + "id": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'ignore_missing_vnet_service_endpoint': {'key': 'ignoreMissingVnetServiceEndpoint', 'type': 'bool'}, + "id": {"key": "id", "type": "str"}, + "ignore_missing_vnet_service_endpoint": {"key": "ignoreMissingVnetServiceEndpoint", "type": "bool"}, } def __init__( self, *, - id: str, + id: str, # pylint: disable=redefined-builtin ignore_missing_vnet_service_endpoint: Optional[bool] = None, **kwargs ): """ - :keyword id: Required. Full resource id of a vnet subnet, such as + :keyword id: Full resource id of a vnet subnet, such as '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. + 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(VirtualNetworkRule, self).__init__(**kwargs) + 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index 49be258e3efc..9e5cd053e465 100644 --- 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 @@ -19,16 +19,17 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'KeysOperations', - 'VaultsOperations', - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'ManagedHsmsOperations', - 'MHSMPrivateEndpointConnectionsOperations', - 'MHSMPrivateLinkResourcesOperations', - 'Operations', - 'SecretsOperations', + "KeysOperations", + "VaultsOperations", + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "ManagedHsmsOperations", + "MHSMPrivateEndpointConnectionsOperations", + "MHSMPrivateLinkResourcesOperations", + "Operations", + "SecretsOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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 index 7eb1ba547baa..58a19cc919fc 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -20,214 +26,176 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - *, - json: Optional[_models.KeyCreateParameters] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_version_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - key_version: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_versions_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class KeysOperations: """ @@ -248,14 +216,15 @@ def __init__(self, *args, **kwargs): 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") - - @distributed_trace + @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 @@ -263,42 +232,120 @@ def create_if_not_exist( subsequent versions, and does not update existing keys. :param resource_group_name: The name of the resource group which contains the specified key - vault. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. + :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. + :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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_if_not_exist( + self, + resource_group_name: str, + vault_name: str, + key_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a + IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - _json = self._serialize.body(parameters, 'KeyCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "KeyCreateParameters") request = build_create_if_not_exist_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.create_if_not_exist.metadata['url'], + content=_content, + template_url=self.create_if_not_exist.metadata["url"], headers=_headers, params=_params, ) @@ -306,67 +353,61 @@ def create_if_not_exist( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_if_not_exist.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + create_if_not_exist.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> _models.Key: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. + :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. + :param key_name: The name of the key to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -374,65 +415,61 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace - def list( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> Iterable[_models.KeyListResult]: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. + :param vault_name: The name of the vault which contains the keys to be retrieved. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -440,15 +477,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -465,10 +504,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -478,57 +515,53 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore @distributed_trace def get_version( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - key_version: str, - **kwargs: Any + 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. + 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. + :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. + :param key_version: The version of the key to be retrieved. Required. :type key_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_version_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get_version.metadata['url'], + template_url=self.get_version.metadata["url"], headers=_headers, params=_params, ) @@ -536,69 +569,67 @@ def get_version( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_version.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore - + get_version.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore @distributed_trace def list_versions( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> Iterable[_models.KeyListResult]: + 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. + 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. + :param key_name: The name of the key versions to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_versions_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_versions.metadata['url'], + template_url=self.list_versions.metadata["url"], headers=_headers, params=_params, ) @@ -606,16 +637,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_versions_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -632,10 +664,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -645,8 +675,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_versions.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore + list_versions.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore 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 index ecce7209b39c..a47d0070cc5e 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,358 +28,281 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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_initial( - resource_group_name: str, - name: str, - subscription_id: str, - *, - json: Optional[_models.ManagedHsm] = None, - content: Any = None, - **kwargs: Any + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) - - -def build_update_request_initial( - resource_group_name: str, - name: str, - subscription_id: str, - *, - json: Optional[_models.ManagedHsm] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) - - -def build_delete_request_initial( - resource_group_name: str, - name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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["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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_list_deleted_request( - subscription_id: str, - **kwargs: Any -) -> HttpRequest: +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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["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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "name": _SERIALIZER.url("name", name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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_initial( - name: str, - location: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "name": _SERIALIZER.url("name", name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class ManagedHsmsOperations: """ @@ -394,36 +323,41 @@ def __init__(self, *args, **kwargs): 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") - def _create_or_update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -431,46 +365,51 @@ def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - - @distributed_trace + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. + :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 :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -482,20 +421,84 @@ def begin_create_or_update( :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 + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], **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 model type + or a IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -503,69 +506,71 @@ def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore def _update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_update_request_initial( + 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, - template_url=self._update_initial.metadata['url'], + content=_content, + template_url=self._update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -573,49 +578,54 @@ def _update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + 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 = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - - deserialized = self._deserialize('ManagedHsm', pipeline_response) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + _update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - - @distributed_trace + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to patch the managed HSM Pool. + :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 :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -627,20 +637,84 @@ def begin_update( :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 + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def begin_update( + self, + resource_group_name: str, + name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._update_initial( # type: ignore resource_group_name=resource_group_name, @@ -648,64 +722,59 @@ def begin_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore def _delete_initial( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any + self, resource_group_name: str, name: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_delete_request_initial( + request = build_delete_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -713,34 +782,29 @@ def _delete_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **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) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace - def begin_delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param name: The name of the managed HSM Pool to delete. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -752,92 +816,83 @@ def begin_delete( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore resource_group_name=resource_group_name, name=name, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> Optional[_models.ManagedHsm]: + 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. + :param name: The name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ManagedHsm, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.ManagedHsm]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.ManagedHsm]] - request = build_get_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -845,10 +900,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -858,56 +912,56 @@ def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -915,15 +969,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -940,10 +996,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -954,48 +1008,45 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -1003,14 +1054,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1027,10 +1081,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1041,44 +1093,42 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> Iterable[_models.DeletedManagedHsmListResult]: + def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedManagedHsm"]: """The List operation gets information about the deleted managed HSMs associated with the subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedManagedHsmListResult or the result of - cls(response) + :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.DeletedManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1086,13 +1136,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1109,10 +1163,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1123,48 +1175,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore @distributed_trace - def get_deleted( - self, - name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedManagedHsm: + 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. + :param name: The name of the deleted managed HSM. Required. :type name: str - :param location: The location of the deleted managed HSM. + :param location: The location of the deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedManagedHsm, or the result of cls(response) + :return: DeletedManagedHsm or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedManagedHsm - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsm] - request = build_get_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1172,10 +1219,9 @@ def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -1183,40 +1229,38 @@ def get_deleted( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DeletedManagedHsm', pipeline_response) + deserialized = self._deserialize("DeletedManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any + self, name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -1224,34 +1268,28 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore @distributed_trace - def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param name: The name of the soft-deleted managed HSM. Required. :type name: str - :param location: The location of the soft-deleted managed HSM. + :param location: The location of the soft-deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -1263,52 +1301,45 @@ def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._purge_deleted_initial( # type: ignore name=name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # 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 index 6a9e46cadead..ea443b50591e 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,173 +28,151 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - subscription_id: str, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_put_request( - subscription_id: str, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - *, - json: Optional[_models.MHSMPrivateEndpointConnection] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) - - -def build_delete_request_initial( - subscription_id: str, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + _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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class MHSMPrivateEndpointConnectionsOperations: """ @@ -209,47 +193,48 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def list_by_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> Iterable[_models.MHSMPrivateEndpointConnectionsListResult]: + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either MHSMPrivateEndpointConnectionsListResult or the - result of cls(response) + :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.MHSMPrivateEndpointConnectionsListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -257,15 +242,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -282,10 +269,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -296,53 +281,50 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -350,10 +332,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -361,15 +342,78 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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( @@ -377,48 +421,64 @@ def put( resource_group_name: str, name: str, private_endpoint_connection_name: str, - properties: _models.MHSMPrivateEndpointConnection, + properties: Union[_models.MHSMPrivateEndpointConnection, IO], **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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :param properties: The intended state of private endpoint connection. Is either a model type or + a IO type. Required. :type properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - _json = self._serialize.body(properties, 'MHSMPrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -426,10 +486,9 @@ def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -437,45 +496,44 @@ def put( 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')) + 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) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore def _delete_initial( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.MHSMPrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -483,10 +541,9 @@ def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -496,37 +553,32 @@ def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def begin_delete( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -540,55 +592,48 @@ def begin_delete( result of cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 index 392580d15a06..9502f1b73ecd 100644 --- 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 @@ -8,9 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,48 +24,46 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class MHSMPrivateLinkResourcesOperations: """ @@ -81,43 +84,42 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def list_by_mhsm_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateLinkResourceListResult, or the result of cls(response) + :return: MHSMPrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.MHSMPrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] - request = build_list_by_mhsm_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_mhsm_resource.metadata['url'], + template_url=self.list_by_mhsm_resource.metadata["url"], headers=_headers, params=_params, ) @@ -125,22 +127,20 @@ def list_by_mhsm_resource( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_mhsm_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # type: ignore - + list_by_mhsm_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # 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 index f44aa0f4efb0..f8e0ee5a922f 100644 --- 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 @@ -7,10 +7,16 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +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.pipeline.transport import HttpResponse @@ -20,38 +26,34 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request -T = TypeVar('T') + +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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class Operations: """ @@ -72,36 +74,35 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> Iterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -109,12 +110,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -131,10 +137,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -144,8 +148,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # type: ignore 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index b9619e75a858..82469743dfe3 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,173 +28,163 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_put_request( - subscription_id: str, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, - *, - json: Optional[_models.PrivateEndpointConnection] = None, - content: Any = None, + subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) -def build_delete_request_initial( - subscription_id: str, +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_resource_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateEndpointConnectionsOperations: """ @@ -209,48 +205,45 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def get( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -258,10 +251,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -270,64 +262,140 @@ def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - @distributed_trace + @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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection or + IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - _json = self._serialize.body(properties, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "PrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -335,10 +403,9 @@ def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -346,45 +413,44 @@ def put( 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')) + 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore def _delete_initial( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -392,10 +458,9 @@ def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -405,37 +470,31 @@ def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def begin_delete( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -449,99 +508,93 @@ def begin_delete( of cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def list_by_resource( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> Iterable[_models.PrivateEndpointConnectionListResult]: + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either PrivateEndpointConnectionListResult or the result - of cls(response) + :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.PrivateEndpointConnectionListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnectionListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -549,15 +602,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -574,10 +629,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -587,8 +640,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore 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 index 0e33e27942ae..4cdea17c64d0 100644 --- 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 @@ -8,9 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,48 +24,46 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateLinkResourcesOperations: """ @@ -81,43 +84,41 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def list_by_vault( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateLinkResourceListResult, or the result of cls(response) + :return: PrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.PrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] - request = build_list_by_vault_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_vault.metadata['url'], + template_url=self.list_by_vault.metadata["url"], headers=_headers, params=_params, ) @@ -125,22 +126,20 @@ def list_by_vault( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_vault.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore - + list_by_vault.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # 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 index dde2add8c876..0299583348ed 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -20,185 +26,150 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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, - *, - json: Optional[_models.SecretCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + 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, - *, - json: Optional[_models.SecretPatchParameters] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class SecretsOperations: """ @@ -219,14 +190,15 @@ def __init__(self, *args, **kwargs): 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") - - @distributed_trace + @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 @@ -234,32 +206,111 @@ def create_or_update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :param secret_name: Name of the secret. Required. :type secret_name: str - :param parameters: Parameters to create or update the secret. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or a IO + type. Required. + :type parameters: + ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -269,7 +320,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -277,10 +329,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -288,26 +339,27 @@ def create_or_update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - @distributed_trace + @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 @@ -315,31 +367,109 @@ def update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :param secret_name: Name of the secret. Required. :type secret_name: str - :param parameters: Parameters to patch the secret. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update( + self, + resource_group_name: str, + vault_name: str, + secret_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -349,7 +479,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -357,10 +488,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -368,60 +498,56 @@ def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - **kwargs: Any - ) -> _models.Secret: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param secret_name: The name of the secret. + :param secret_name: The name of the secret. Required. :type secret_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -429,70 +555,68 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace def list( - self, - resource_group_name: str, - vault_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.SecretListResult]: + 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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SecretListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.SecretListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SecretListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SecretListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, top=top, - template_url=self.list.metadata['url'], + api_version=api_version, + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -500,16 +624,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -526,10 +651,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -539,8 +662,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore 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 index 1d717cd20a35..f56328c06186 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,485 +28,377 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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_initial( - resource_group_name: str, - vault_name: str, - subscription_id: str, - *, - json: Optional[_models.VaultCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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, - *, - json: Optional[_models.VaultPatchParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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"], + operation_kind: Union[str, _models.AccessPolicyUpdateKind], subscription_id: str, - *, - json: Optional[_models.VaultAccessPolicyParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_purge_deleted_request_initial( - vault_name: str, - location: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + 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 + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - accept = _headers.pop('Accept', "application/json") + filter = kwargs.pop("filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') + _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') + _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 - ) + _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, - *, - json: Optional[_models.VaultCheckNameAvailabilityParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability") + _url = kwargs.pop( + "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability" + ) path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: """ @@ -521,36 +419,45 @@ def __init__(self, *args, **kwargs): 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") - def _create_or_update_initial( self, resource_group_name: str, vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **kwargs: Any ) -> _models.Vault: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -558,10 +465,9 @@ def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -569,35 +475,110 @@ def _create_or_update_initial( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :param parameters: Parameters to create or update the vault. Is either a model type or a IO + type. Required. :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultCreateOrUpdateParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -608,20 +589,17 @@ def begin_create_or_update( Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -629,74 +607,140 @@ def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -705,7 +749,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -713,10 +758,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -724,55 +768,54 @@ def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -780,10 +823,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -793,45 +835,42 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -839,64 +878,144 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # 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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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: _models.VaultAccessPolicyParameters, + operation_kind: Union[str, _models.AccessPolicyUpdateKind], + parameters: Union[_models.VaultAccessPolicyParameters, IO], **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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :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. + :param parameters: Access policy to merge into the vault. Is either a model type or a IO type. + Required. :type parameters: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -906,7 +1025,8 @@ def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -914,10 +1034,9 @@ def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -925,58 +1044,58 @@ def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -984,15 +1103,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1009,10 +1130,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1022,46 +1141,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -1069,14 +1185,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1093,10 +1212,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1106,43 +1223,41 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> Iterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) + :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.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1150,13 +1265,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1173,10 +1292,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1186,48 +1303,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace - def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1235,50 +1347,47 @@ def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -1286,10 +1395,9 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -1299,21 +1407,15 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace - def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -1325,62 +1427,51 @@ def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace - def list( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.ResourceListResult]: + 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. @@ -1393,31 +1484,36 @@ def list( that overriding this default value may result in unsupported behavior. :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_06_01_preview.models.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + filter = kwargs.pop( + "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") + ) # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -1425,15 +1521,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1450,10 +1548,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1463,48 +1559,96 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace + @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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_06_01_preview.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def check_name_availability( + self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO], **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 model type or a IO type. Required. + :type vault_name: + ~azure.mgmt.keyvault.v2021_06_01_preview.models.VaultCheckNameAvailabilityParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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 = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-06-01-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-06-01-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1512,22 +1656,20 @@ def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore 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 index d19915ab3650..731fc6d4be82 100644 --- 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 @@ -17,7 +17,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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/_configuration.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_configuration.py index 22587b2a6f17..44db480db515 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_configuration.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_configuration.py @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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: "TokenCredential", - subscription_id: str, - **kwargs: Any - ) -> None: + def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2021-10-01") # type: str + api_version = kwargs.pop("api_version", "2021-10-01") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,23 +47,24 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) self._configure(**kwargs) def _configure( - self, - **kwargs # type: Any + self, **kwargs # type: Any ): # type: (...) -> 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.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs) + 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) + self.authentication_policy = ARMChallengeAuthenticationPolicy( + self.credential, *self.credential_scopes, **kwargs + ) 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 index 6768b5ee29be..b33b54f35f00 100644 --- 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 @@ -9,20 +9,30 @@ from copy import deepcopy from typing import Any, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import HttpRequest, HttpResponse from azure.mgmt.core import ARMPipelineClient from . import models +from .._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration -from .operations import KeysOperations, MHSMPrivateEndpointConnectionsOperations, MHSMPrivateLinkResourcesOperations, ManagedHsmsOperations, Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, SecretsOperations, VaultsOperations +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=too-many-instance-attributes + +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. @@ -48,10 +58,10 @@ class KeyVaultManagementClient: # pylint: disable=too-many-instance-attribute :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. + :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. + 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 @@ -69,47 +79,34 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = ARMPipelineClient(base_url=base_url, config=self._config, **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 - ) - self.vaults = VaultsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize) + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) self.private_endpoint_connections = PrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.managed_hsms = ManagedHsmsOperations(self._client, self._config, self._serialize, self._deserialize) self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - self.secrets = SecretsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) + self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize) - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> HttpResponse: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -118,7 +115,7 @@ def _send_request( >>> response = client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 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 index 1610a3d9e295..aab39de05141 100644 --- 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 @@ -10,20 +10,20 @@ "azure_arm": true, "has_lro_operations": true, "client_side_validation": false, - "sync_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"ARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}", - "async_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"], \"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"AsyncARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}" + "sync_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"ARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \".._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", + "async_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"AsyncARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \"..._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" }, "global_parameters": { "sync": { "credential": { - "signature": "credential, # type: \"TokenCredential\"", - "description": "Credential needed for the client to connect to Azure.", + "signature": "credential: \"TokenCredential\",", + "description": "Credential needed for the client to connect to Azure. Required.", "docstring_type": "~azure.core.credentials.TokenCredential", "required": true }, "subscription_id": { - "signature": "subscription_id, # type: str", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.", + "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 } @@ -31,13 +31,13 @@ "async": { "credential": { "signature": "credential: \"AsyncTokenCredential\",", - "description": "Credential needed for the client to connect to Azure.", + "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.", + "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 } @@ -54,7 +54,7 @@ "required": false }, "base_url": { - "signature": "base_url=\"https://management.azure.com\", # type: str", + "signature": "base_url: str = \"https://management.azure.com\",", "description": "Service URL", "docstring_type": "str", "required": false 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 index 74e48ecd07cf..f99e77fef986 100644 --- 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 @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_vendor.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_vendor.py index 138f663c53a4..9aad73fc743e 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_vendor.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2021_10_01/_vendor.py @@ -7,6 +7,7 @@ from azure.core.pipeline.transport import HttpRequest + def _convert_request(request, files=None): data = request.content if not files else None request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) @@ -14,6 +15,7 @@ def _convert_request(request, files=None): request.set_formdata_body(files) return request + def _format_url_section(template, **kwargs): components = template.split("/") while components: @@ -21,7 +23,5 @@ def _format_url_section(template, **kwargs): return template.format(**kwargs) except KeyError as key: formatted_components = template.split("/") - components = [ - c for c in formatted_components if "{}".format(key.args[0]) not in c - ] + components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] template = "/".join(components) 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 index c1257f7f4e11..e5754a47ce68 100644 --- 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 @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "10.1.0" +VERSION = "1.0.0b1" 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 index 1aa2a0b291a3..c2c64fd1638f 100644 --- 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 @@ -14,7 +14,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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 index fa519bf3ed2e..0f82fb08a7c7 100644 --- 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 @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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: + def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2021-10-01") # type: str + api_version = kwargs.pop("api_version", "2021-10-01") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,22 +47,21 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) 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.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) + 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) + 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 index 84e102d61063..fec9d5ddfef9 100644 --- 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 @@ -9,20 +9,30 @@ from copy import deepcopy from typing import Any, Awaitable, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.mgmt.core import AsyncARMPipelineClient from .. import models +from ..._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration -from .operations import KeysOperations, MHSMPrivateEndpointConnectionsOperations, MHSMPrivateLinkResourcesOperations, ManagedHsmsOperations, Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, SecretsOperations, VaultsOperations +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=too-many-instance-attributes + +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. @@ -48,10 +58,10 @@ class KeyVaultManagementClient: # pylint: disable=too-many-instance-attribute :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. + :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. + 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 @@ -69,47 +79,34 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **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 - ) - self.vaults = VaultsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize) + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) self.private_endpoint_connections = PrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.managed_hsms = ManagedHsmsOperations(self._client, self._config, self._serialize, self._deserialize) self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - self.secrets = SecretsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) + self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize) - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -118,7 +115,7 @@ def _send_request( >>> response = await client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 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 index 74e48ecd07cf..f99e77fef986 100644 --- 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 @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass 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 index 49be258e3efc..9e5cd053e465 100644 --- 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 @@ -19,16 +19,17 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'KeysOperations', - 'VaultsOperations', - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'ManagedHsmsOperations', - 'MHSMPrivateEndpointConnectionsOperations', - 'MHSMPrivateLinkResourcesOperations', - 'Operations', - 'SecretsOperations', + "KeysOperations", + "VaultsOperations", + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "ManagedHsmsOperations", + "MHSMPrivateEndpointConnectionsOperations", + "MHSMPrivateLinkResourcesOperations", + "Operations", + "SecretsOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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 index 97c2b450e0b7..aa5648007b70 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,10 +28,18 @@ from ... import models as _models from ..._vendor import _convert_request -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 -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class KeysOperations: """ .. warning:: @@ -43,14 +59,15 @@ def __init__(self, *args, **kwargs) -> None: 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") - - @distributed_trace_async + @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 @@ -58,42 +75,126 @@ async def create_if_not_exist( subsequent versions, and does not update existing keys. :param resource_group_name: The name of the resource group which contains the specified key - vault. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. + :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. + :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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or a + IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.KeyCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Key or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - _json = self._serialize.body(parameters, 'KeyCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "KeyCreateParameters") request = build_create_if_not_exist_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.create_if_not_exist.metadata['url'], + content=_content, + template_url=self.create_if_not_exist.metadata["url"], headers=_headers, params=_params, ) @@ -101,67 +202,61 @@ async def create_if_not_exist( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_if_not_exist.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + create_if_not_exist.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> _models.Key: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. + :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. + :param key_name: The name of the key to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -169,65 +264,61 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace - def list( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.KeyListResult]: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. + :param vault_name: The name of the vault which contains the keys to be retrieved. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -235,15 +326,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -260,10 +353,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -273,57 +364,53 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore @distributed_trace_async async def get_version( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - key_version: str, - **kwargs: Any + 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. + 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. + :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. + :param key_version: The version of the key to be retrieved. Required. :type key_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_version_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get_version.metadata['url'], + template_url=self.get_version.metadata["url"], headers=_headers, params=_params, ) @@ -331,69 +418,67 @@ async def get_version( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_version.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore - + get_version.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore @distributed_trace def list_versions( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.KeyListResult]: + 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. + 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. + :param key_name: The name of the key versions to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_versions_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_versions.metadata['url'], + template_url=self.list_versions.metadata["url"], headers=_headers, params=_params, ) @@ -401,16 +486,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_versions_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -427,10 +513,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -440,8 +524,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_versions.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore + list_versions.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore 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 index 10ff407939ea..688a6f6f325a 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,22 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._managed_hsms_operations import build_create_or_update_request_initial, build_delete_request_initial, 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_initial, build_update_request_initial -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class ManagedHsmsOperations: """ .. warning:: @@ -45,36 +65,41 @@ def __init__(self, *args, **kwargs) -> None: 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") - async def _create_or_update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -82,46 +107,118 @@ async def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - - @distributed_trace_async + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], **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 model type + or a IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -133,20 +230,17 @@ async def begin_create_or_update( :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -154,69 +248,71 @@ async def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore async def _update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_update_request_initial( + 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, - template_url=self._update_initial.metadata['url'], + content=_content, + template_url=self._update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -224,49 +320,90 @@ async def _update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + 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 = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - - deserialized = self._deserialize('ManagedHsm', pipeline_response) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + _update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - - @distributed_trace_async + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to patch the managed HSM Pool. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -278,20 +415,48 @@ async def begin_update( :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 + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def begin_update( + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._update_initial( # type: ignore resource_group_name=resource_group_name, @@ -299,64 +464,59 @@ async def begin_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore async def _delete_initial( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any + self, resource_group_name: str, name: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_delete_request_initial( + request = build_delete_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -364,34 +524,29 @@ async def _delete_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **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) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace_async - async def begin_delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param name: The name of the managed HSM Pool to delete. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -403,92 +558,83 @@ async def begin_delete( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore resource_group_name=resource_group_name, name=name, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> Optional[_models.ManagedHsm]: + 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. + :param name: The name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ManagedHsm, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.ManagedHsm]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.ManagedHsm]] - request = build_get_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -496,10 +642,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -509,56 +654,56 @@ async def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -566,15 +711,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -591,10 +738,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -605,48 +750,45 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -654,14 +796,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -678,10 +823,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -692,44 +835,42 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> AsyncIterable[_models.DeletedManagedHsmListResult]: + def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedManagedHsm"]: """The List operation gets information about the deleted managed HSMs associated with the subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedManagedHsmListResult or the result of - cls(response) + :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.DeletedManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -737,13 +878,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -760,10 +905,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -774,48 +917,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore @distributed_trace_async - async def get_deleted( - self, - name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedManagedHsm: + 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. + :param name: The name of the deleted managed HSM. Required. :type name: str - :param location: The location of the deleted managed HSM. + :param location: The location of the deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedManagedHsm, or the result of cls(response) + :return: DeletedManagedHsm or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.DeletedManagedHsm - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsm] - request = build_get_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -823,10 +961,9 @@ async def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -834,40 +971,38 @@ async def get_deleted( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DeletedManagedHsm', pipeline_response) + deserialized = self._deserialize("DeletedManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore async def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any + self, name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -875,34 +1010,28 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore @distributed_trace_async - async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param name: The name of the soft-deleted managed HSM. Required. :type name: str - :param location: The location of the soft-deleted managed HSM. + :param location: The location of the soft-deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -914,52 +1043,45 @@ async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._purge_deleted_initial( # type: ignore name=name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # 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 index 9531607d0ee2..45cde7f15e9f 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,17 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._mhsm_private_endpoint_connections_operations import build_delete_request_initial, build_get_request, build_list_by_resource_request, build_put_request -T = TypeVar('T') +from ...operations._mhsm_private_endpoint_connections_operations import ( + build_delete_request, + build_get_request, + build_list_by_resource_request, + build_put_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class MHSMPrivateEndpointConnectionsOperations: """ .. warning:: @@ -45,47 +60,48 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace def list_by_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> AsyncIterable[_models.MHSMPrivateEndpointConnectionsListResult]: + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either MHSMPrivateEndpointConnectionsListResult or the - result of cls(response) + :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.MHSMPrivateEndpointConnectionsListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -93,15 +109,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -118,10 +136,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -132,53 +148,50 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -186,10 +199,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -197,64 +209,142 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - - @distributed_trace_async + @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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - _json = self._serialize.body(properties, 'MHSMPrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -262,10 +352,9 @@ async def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -273,45 +362,44 @@ async def put( 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')) + 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) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore async def _delete_initial( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.MHSMPrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -319,10 +407,9 @@ async def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -332,37 +419,32 @@ async def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace_async async def begin_delete( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -376,55 +458,48 @@ async def begin_delete( result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore 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/v2021_10_01/aio/operations/_mhsm_private_link_resources_operations.py index b7a9de380631..502133845369 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/v2021_10_01/aio/operations/_mhsm_private_link_resources_operations.py @@ -8,7 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -19,9 +26,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._mhsm_private_link_resources_operations import build_list_by_mhsm_resource_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class MHSMPrivateLinkResourcesOperations: """ .. warning:: @@ -41,43 +50,42 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def list_by_mhsm_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateLinkResourceListResult, or the result of cls(response) + :return: MHSMPrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] - request = build_list_by_mhsm_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_mhsm_resource.metadata['url'], + template_url=self.list_by_mhsm_resource.metadata["url"], headers=_headers, params=_params, ) @@ -85,22 +93,20 @@ async def list_by_mhsm_resource( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_mhsm_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # type: ignore - + list_by_mhsm_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # 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 index 126b1620838a..fc4254752d0c 100644 --- 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 @@ -7,9 +7,17 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,9 +28,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._operations import build_list_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class Operations: """ .. warning:: @@ -42,36 +52,36 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> AsyncIterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) + :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.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -79,12 +89,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -101,10 +116,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -114,8 +127,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # type: ignore 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index 7661a462d8ff..5e02eb1fe6e0 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,17 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._private_endpoint_connections_operations import build_delete_request_initial, build_get_request, build_list_by_resource_request, build_put_request -T = TypeVar('T') +from ...operations._private_endpoint_connections_operations import ( + build_delete_request, + build_get_request, + build_list_by_resource_request, + build_put_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateEndpointConnectionsOperations: """ .. warning:: @@ -45,48 +60,45 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def get( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -94,10 +106,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -106,64 +117,139 @@ async def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - @distributed_trace_async + @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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: PrivateEndpointConnection or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - _json = self._serialize.body(properties, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "PrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -171,10 +257,9 @@ async def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -182,45 +267,44 @@ async def put( 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')) + 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore async def _delete_initial( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -228,10 +312,9 @@ async def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -241,37 +324,31 @@ async def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace_async async def begin_delete( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -285,99 +362,93 @@ async def begin_delete( result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def list_by_resource( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.PrivateEndpointConnectionListResult]: + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either PrivateEndpointConnectionListResult or the result - of cls(response) + :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.PrivateEndpointConnectionListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnectionListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -385,15 +456,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -410,10 +483,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -423,8 +494,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore 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 index 179a0030416e..56d97bc9dfd6 100644 --- 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 @@ -8,7 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -19,9 +26,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._private_link_resources_operations import build_list_by_vault_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateLinkResourcesOperations: """ .. warning:: @@ -41,43 +50,41 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def list_by_vault( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateLinkResourceListResult, or the result of cls(response) + :return: PrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] - request = build_list_by_vault_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_vault.metadata['url'], + template_url=self.list_by_vault.metadata["url"], headers=_headers, params=_params, ) @@ -85,22 +92,20 @@ async def list_by_vault( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_vault.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore - + list_by_vault.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # 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 index d5998705c07b..3d3470f64c31 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,10 +28,17 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._secrets_operations import build_create_or_update_request, build_get_request, build_list_request, build_update_request -T = TypeVar('T') +from ...operations._secrets_operations import ( + build_create_or_update_request, + build_get_request, + build_list_request, + build_update_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class SecretsOperations: """ .. warning:: @@ -43,14 +58,15 @@ def __init__(self, *args, **kwargs) -> None: 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") - - @distributed_trace_async + @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 @@ -58,31 +74,115 @@ async def create_or_update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.SecretCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -92,7 +192,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -100,10 +201,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -111,26 +211,27 @@ async def create_or_update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - @distributed_trace_async + @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 @@ -138,31 +239,109 @@ async def update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :param secret_name: Name of the secret. Required. :type secret_name: str - :param parameters: Parameters to patch the secret. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.SecretPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -172,7 +351,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -180,10 +360,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -191,60 +370,56 @@ async def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - **kwargs: Any - ) -> _models.Secret: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param secret_name: The name of the secret. + :param secret_name: The name of the secret. Required. :type secret_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -252,70 +427,68 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace def list( - self, - resource_group_name: str, - vault_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.SecretListResult]: + 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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SecretListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.SecretListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SecretListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SecretListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, top=top, - template_url=self.list.metadata['url'], + api_version=api_version, + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -323,16 +496,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -349,10 +523,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -362,8 +534,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore 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 index 31703cfbf05c..a48203f7ac58 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,25 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._vaults_operations import build_check_name_availability_request, build_create_or_update_request_initial, 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_initial, build_update_access_policy_request, build_update_request -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class VaultsOperations: """ .. warning:: @@ -45,36 +68,45 @@ def __init__(self, *args, **kwargs) -> None: 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") - async def _create_or_update_initial( self, resource_group_name: str, vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **kwargs: Any ) -> _models.Vault: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -82,10 +114,9 @@ async def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -93,35 +124,109 @@ async def _create_or_update_initial( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - - @distributed_trace_async + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], + **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -132,20 +237,17 @@ async def begin_create_or_update( Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -153,74 +255,140 @@ async def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace_async + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -229,7 +397,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -237,10 +406,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -248,55 +416,54 @@ async def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -304,10 +471,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -317,45 +483,42 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -363,63 +526,140 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - - @distributed_trace_async + @overload async def update_access_policy( self, resource_group_name: str, vault_name: str, - operation_kind: Union[str, "_models.AccessPolicyUpdateKind"], + 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: VaultAccessPolicyParameters or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -429,7 +669,8 @@ async def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -437,10 +678,9 @@ async def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -448,58 +688,58 @@ async def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -507,15 +747,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -532,10 +774,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -545,46 +785,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -592,14 +829,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -616,10 +856,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -629,43 +867,41 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> AsyncIterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) + :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.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -673,13 +909,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -696,10 +936,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -709,48 +947,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace_async - async def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -758,50 +991,47 @@ async def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore async def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -809,10 +1039,9 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -822,21 +1051,15 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace_async - async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -848,62 +1071,51 @@ async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace - def list( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.ResourceListResult]: + 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. @@ -916,31 +1128,37 @@ def list( that overriding this default value may result in unsupported behavior. :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) + :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.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + filter = kwargs.pop( + "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") + ) # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -948,15 +1166,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -973,10 +1193,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -986,47 +1204,95 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace_async + @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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def check_name_availability( + self, vault_name: IO, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], **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 model type or a IO type. Required. + :type vault_name: ~azure.mgmt.keyvault.v2021_10_01.models.VaultCheckNameAvailabilityParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CheckNameAvailabilityResult or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.CheckNameAvailabilityResult + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1034,22 +1300,20 @@ async def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # 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 index f0b287a64ffa..686489627084 100644 --- 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 @@ -77,131 +77,129 @@ from ._models_py3 import VaultProperties from ._models_py3 import VirtualNetworkRule - -from ._key_vault_management_client_enums import ( - AccessPolicyUpdateKind, - ActionsRequired, - CertificatePermissions, - CreateMode, - DeletionRecoveryLevel, - IdentityType, - JsonWebKeyCurveName, - JsonWebKeyOperation, - JsonWebKeyType, - KeyPermissions, - ManagedHsmSkuFamily, - ManagedHsmSkuName, - NetworkRuleAction, - NetworkRuleBypassOptions, - PrivateEndpointConnectionProvisioningState, - PrivateEndpointServiceConnectionStatus, - ProvisioningState, - PublicNetworkAccess, - Reason, - SecretPermissions, - SkuFamily, - SkuName, - StoragePermissions, - VaultProvisioningState, -) +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 * # type: ignore # 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', + "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() \ No newline at end of file +_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 index 2cee448ee123..a3215201a826 100644 --- 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 @@ -11,25 +11,28 @@ 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. - """ + """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_ENUM = "import" + IMPORT = "import" UPDATE = "update" MANAGECONTACTS = "managecontacts" GETISSUERS = "getissuers" @@ -42,13 +45,14 @@ class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): BACKUP = "backup" RESTORE = "restore" + class CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The vault's create mode to indicate whether the vault need to be recovered or not. - """ + """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 @@ -60,24 +64,25 @@ class DeletionRecoveryLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta): RECOVERABLE = "Recoverable" RECOVERABLE_PROTECTED_SUBSCRIPTION = "Recoverable+ProtectedSubscription" + class IdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of identity. - """ + """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. - """ + """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. @@ -89,18 +94,20 @@ class JsonWebKeyOperation(str, Enum, metaclass=CaseInsensitiveEnumMeta): VERIFY = "verify" WRAP_KEY = "wrapKey" UNWRAP_KEY = "unwrapKey" - IMPORT_ENUM = "import" + IMPORT = "import" + class JsonWebKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of the key. For valid values, see JsonWebKeyType. - """ + """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" @@ -113,26 +120,27 @@ class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): LIST = "list" CREATE = "create" UPDATE = "update" - IMPORT_ENUM = "import" + IMPORT = "import" DELETE = "delete" BACKUP = "backup" RESTORE = "restore" RECOVER = "recover" PURGE = "purge" + class ManagedHsmSkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU Family of the managed HSM Pool - """ + """SKU Family of the managed HSM Pool.""" B = "B" + class ManagedHsmSkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU of the managed HSM Pool - """ + """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. @@ -141,6 +149,7 @@ class NetworkRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta): 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'. @@ -149,9 +158,9 @@ class NetworkRuleBypassOptions(str, Enum, metaclass=CaseInsensitiveEnumMeta): AZURE_SERVICES = "AzureServices" NONE = "None" + class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The current provisioning state. - """ + """The current provisioning state.""" SUCCEEDED = "Succeeded" CREATING = "Creating" @@ -160,18 +169,18 @@ class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsens FAILED = "Failed" DISCONNECTED = "Disconnected" + class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The private endpoint connection status. - """ + """The private endpoint connection status.""" PENDING = "Pending" APPROVED = "Approved" REJECTED = "Rejected" DISCONNECTED = "Disconnected" + class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state. - """ + """Provisioning state.""" #: The managed HSM Pool has been full provisioned. SUCCEEDED = "Succeeded" @@ -190,6 +199,7 @@ class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): #: The managed HSM pool is being restored from full HSM backup. RESTORING = "Restoring" + class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Control permission for data plane traffic coming from public networks while private endpoint is enabled. @@ -198,6 +208,7 @@ class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta): 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. @@ -206,7 +217,9 @@ class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta): ACCOUNT_NAME_INVALID = "AccountNameInvalid" ALREADY_EXISTS = "AlreadyExists" + class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """SecretPermissions.""" ALL = "all" GET = "get" @@ -218,20 +231,22 @@ class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): RECOVER = "recover" PURGE = "purge" + class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU family name - """ + """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. - """ + """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" @@ -249,9 +264,9 @@ class StoragePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): GETSAS = "getsas" DELETESAS = "deletesas" + class VaultProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state of the vault. - """ + """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 index a4f8f39b767c..841435af1417 100644 --- 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 @@ -1,4 +1,5 @@ # 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. @@ -9,43 +10,42 @@ import datetime from typing import Dict, List, Optional, TYPE_CHECKING, Union -from azure.core.exceptions import HttpResponseError -import msrest.serialization +from ... import _serialization if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - import __init__ as _models + from .. import models as _models -class AccessPolicyEntry(msrest.serialization.Model): +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 Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and certificates. + :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}, + "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'}, + "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__( @@ -58,27 +58,27 @@ def __init__( **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and - certificates. + :keyword permissions: Permissions the identity has for keys, secrets and certificates. + Required. :paramtype permissions: ~azure.mgmt.keyvault.v2021_10_01.models.Permissions """ - super(AccessPolicyEntry, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.object_id = object_id self.application_id = application_id self.permissions = permissions -class Attributes(msrest.serialization.Model): +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. @@ -96,16 +96,16 @@ class Attributes(msrest.serialization.Model): """ _validation = { - 'created': {'readonly': True}, - 'updated': {'readonly': True}, + "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'}, + "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__( @@ -124,7 +124,7 @@ def __init__( :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. :paramtype expires: ~datetime.datetime """ - super(Attributes, self).__init__(**kwargs) + super().__init__(**kwargs) self.enabled = enabled self.not_before = not_before self.expires = expires @@ -132,7 +132,7 @@ def __init__( self.updated = None -class CheckNameAvailabilityResult(msrest.serialization.Model): +class CheckNameAvailabilityResult(_serialization.Model): """The CheckNameAvailability operation response. Variables are only populated by the server, and will be ignored when sending a request. @@ -142,37 +142,33 @@ class CheckNameAvailabilityResult(msrest.serialization.Model): 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", "AlreadyExists". + 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}, + "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'}, + "name_available": {"key": "nameAvailable", "type": "bool"}, + "reason": {"key": "reason", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(CheckNameAvailabilityResult, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.name_available = None self.reason = None self.message = None -class CloudErrorBody(msrest.serialization.Model): +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. @@ -183,17 +179,11 @@ class CloudErrorBody(msrest.serialization.Model): """ _attribute_map = { - 'code': {'key': 'code', 'type': 'str'}, - 'message': {'key': 'message', 'type': 'str'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - *, - code: Optional[str] = None, - message: Optional[str] = None, - **kwargs - ): + def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs): """ :keyword code: Error code. This is a mnemonic that can be consumed programmatically. :paramtype code: str @@ -201,12 +191,12 @@ def __init__( with service version. :paramtype message: str """ - super(CloudErrorBody, self).__init__(**kwargs) + super().__init__(**kwargs) self.code = code self.message = message -class DeletedManagedHsm(msrest.serialization.Model): +class DeletedManagedHsm(_serialization.Model): """DeletedManagedHsm. Variables are only populated by the server, and will be ignored when sending a request. @@ -222,36 +212,31 @@ class DeletedManagedHsm(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "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'}, + "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 - ): + def __init__(self, *, properties: Optional["_models.DeletedManagedHsmProperties"] = None, **kwargs): """ :keyword properties: Properties of the deleted managed HSM. :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.DeletedManagedHsmProperties """ - super(DeletedManagedHsm, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None self.properties = properties -class DeletedManagedHsmListResult(msrest.serialization.Model): +class DeletedManagedHsmListResult(_serialization.Model): """List of deleted managed HSM Pools. :ivar value: The list of deleted managed HSM Pools. @@ -261,16 +246,12 @@ class DeletedManagedHsmListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DeletedManagedHsm]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.DeletedManagedHsm"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of deleted managed HSM Pools. @@ -278,12 +259,12 @@ def __init__( :keyword next_link: The URL to get the next set of deleted managed HSM Pools. :paramtype next_link: str """ - super(DeletedManagedHsmListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class DeletedManagedHsmProperties(msrest.serialization.Model): +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. @@ -298,35 +279,31 @@ class DeletedManagedHsmProperties(msrest.serialization.Model): :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: A set of tags. Tags of the original managed HSM. + :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}, + "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}'}, + "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 - ): - """ - """ - super(DeletedManagedHsmProperties, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.mhsm_id = None self.location = None self.deletion_date = None @@ -335,7 +312,7 @@ def __init__( self.tags = None -class DeletedVault(msrest.serialization.Model): +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. @@ -351,36 +328,31 @@ class DeletedVault(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "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'}, + "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 - ): + def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs): """ :keyword properties: Properties of the vault. :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.DeletedVaultProperties """ - super(DeletedVault, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None self.properties = properties -class DeletedVaultListResult(msrest.serialization.Model): +class DeletedVaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of deleted vaults. @@ -390,16 +362,12 @@ class DeletedVaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DeletedVault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.DeletedVault"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of deleted vaults. @@ -407,12 +375,12 @@ def __init__( :keyword next_link: The URL to get the next set of deleted vaults. :paramtype next_link: str """ - super(DeletedVaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class DeletedVaultProperties(msrest.serialization.Model): +class DeletedVaultProperties(_serialization.Model): """Properties of the deleted vault. Variables are only populated by the server, and will be ignored when sending a request. @@ -425,37 +393,33 @@ class DeletedVaultProperties(msrest.serialization.Model): :vartype deletion_date: ~datetime.datetime :ivar scheduled_purge_date: The scheduled purged date. :vartype scheduled_purge_date: ~datetime.datetime - :ivar tags: A set of tags. Tags of the original vault. + :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}, + "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'}, + "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 - ): - """ - """ - super(DeletedVaultProperties, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.vault_id = None self.location = None self.deletion_date = None @@ -464,7 +428,7 @@ def __init__( self.purge_protection_enabled = None -class DimensionProperties(msrest.serialization.Model): +class DimensionProperties(_serialization.Model): """Type of operation: get, read, delete, etc. :ivar name: Name of dimension. @@ -477,9 +441,9 @@ class DimensionProperties(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'to_be_exported_for_shoebox': {'key': 'toBeExportedForShoebox', 'type': 'bool'}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "to_be_exported_for_shoebox": {"key": "toBeExportedForShoebox", "type": "bool"}, } def __init__( @@ -499,13 +463,13 @@ def __init__( exported for Shoebox. :paramtype to_be_exported_for_shoebox: bool """ - super(DimensionProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.to_be_exported_for_shoebox = to_be_exported_for_shoebox -class Error(msrest.serialization.Model): +class Error(_serialization.Model): """The server error. Variables are only populated by the server, and will be ignored when sending a request. @@ -519,63 +483,54 @@ class Error(msrest.serialization.Model): """ _validation = { - 'code': {'readonly': True}, - 'message': {'readonly': True}, - 'inner_error': {'readonly': True}, + "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'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, + "inner_error": {"key": "innererror", "type": "Error"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(Error, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.code = None self.message = None self.inner_error = None -class IPRule(msrest.serialization.Model): +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 Azure. - :ivar value: Required. 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). + :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}, + "value": {"required": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, + "value": {"key": "value", "type": "str"}, } - def __init__( - self, - *, - value: str, - **kwargs - ): + def __init__(self, *, value: str, **kwargs): """ - :keyword value: Required. 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). + :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(IPRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class Resource(msrest.serialization.Model): +class Resource(_serialization.Model): """Key Vault resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -588,33 +543,29 @@ class Resource(msrest.serialization.Model): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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}, + "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}'}, + "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 - ): - """ - """ - super(Resource, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -622,7 +573,7 @@ def __init__( self.tags = None -class Key(Resource): +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. @@ -635,19 +586,19 @@ class Key(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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", "RSA-HSM". + "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", "P-256K". + 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 @@ -656,28 +607,28 @@ class Key(Resource): """ _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'}, + "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__( @@ -694,17 +645,17 @@ def __init__( :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", "RSA-HSM". + "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", "P-256K". + 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(Key, self).__init__(**kwargs) + super().__init__(**kwargs) self.attributes = attributes self.kty = kty self.key_ops = key_ops @@ -714,7 +665,7 @@ def __init__( self.key_uri_with_version = None -class KeyAttributes(msrest.serialization.Model): +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. @@ -722,17 +673,17 @@ class KeyAttributes(msrest.serialization.Model): :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: long + :vartype not_before: int :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: long + :vartype expires: int :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: long + :vartype created: int :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: long + :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", + 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. @@ -740,19 +691,19 @@ class KeyAttributes(msrest.serialization.Model): """ _validation = { - 'created': {'readonly': True}, - 'updated': {'readonly': True}, - 'recovery_level': {'readonly': True}, + "created": {"readonly": True}, + "updated": {"readonly": True}, + "recovery_level": {"readonly": True}, } _attribute_map = { - 'enabled': {'key': 'enabled', 'type': 'bool'}, - 'not_before': {'key': 'nbf', 'type': 'long'}, - 'expires': {'key': 'exp', 'type': 'long'}, - 'created': {'key': 'created', 'type': 'long'}, - 'updated': {'key': 'updated', 'type': 'long'}, - 'recovery_level': {'key': 'recoveryLevel', 'type': 'str'}, - 'exportable': {'key': 'exportable', 'type': 'bool'}, + "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__( @@ -768,13 +719,13 @@ def __init__( :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: long + :paramtype not_before: int :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :paramtype expires: long + :paramtype expires: int :keyword exportable: Indicates if the private key can be exported. :paramtype exportable: bool """ - super(KeyAttributes, self).__init__(**kwargs) + super().__init__(**kwargs) self.enabled = enabled self.not_before = not_before self.expires = expires @@ -784,45 +735,39 @@ def __init__( self.exportable = exportable -class KeyCreateParameters(msrest.serialization.Model): +class KeyCreateParameters(_serialization.Model): """The parameters used to create a key. All required parameters must be populated in order to send to Azure. - :ivar tags: A set of tags. The tags that will be assigned to the key. + :ivar tags: The tags that will be assigned to the key. :vartype tags: dict[str, str] - :ivar properties: Required. The properties of the key to be created. + :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}, + "properties": {"required": True}, } _attribute_map = { - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'KeyProperties'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "KeyProperties"}, } - def __init__( - self, - *, - properties: "_models.KeyProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs - ): + def __init__(self, *, properties: "_models.KeyProperties", tags: Optional[Dict[str, str]] = None, **kwargs): """ - :keyword tags: A set of tags. The tags that will be assigned to the key. + :keyword tags: The tags that will be assigned to the key. :paramtype tags: dict[str, str] - :keyword properties: Required. The properties of the key to be created. + :keyword properties: The properties of the key to be created. Required. :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.KeyProperties """ - super(KeyCreateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class KeyListResult(msrest.serialization.Model): +class KeyListResult(_serialization.Model): """The page of keys. :ivar value: The key resources. @@ -832,29 +777,23 @@ class KeyListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Key]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Key"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(KeyListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class KeyProperties(msrest.serialization.Model): +class KeyProperties(_serialization.Model): """The properties of the key. Variables are only populated by the server, and will be ignored when sending a request. @@ -862,14 +801,14 @@ class KeyProperties(msrest.serialization.Model): :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", "RSA-HSM". + "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", "P-256K". + 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 @@ -878,18 +817,18 @@ class KeyProperties(msrest.serialization.Model): """ _validation = { - 'key_uri': {'readonly': True}, - 'key_uri_with_version': {'readonly': True}, + "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'}, + "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__( @@ -906,17 +845,17 @@ def __init__( :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", "RSA-HSM". + "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", "P-256K". + 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(KeyProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.attributes = attributes self.kty = kty self.key_ops = key_ops @@ -926,7 +865,7 @@ def __init__( self.key_uri_with_version = None -class LogSpecification(msrest.serialization.Model): +class LogSpecification(_serialization.Model): """Log specification of operation. :ivar name: Name of log specification. @@ -938,9 +877,9 @@ class LogSpecification(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'blob_duration': {'key': 'blobDuration', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "blob_duration": {"key": "blobDuration", "type": "str"}, } def __init__( @@ -959,13 +898,13 @@ def __init__( :keyword blob_duration: Blob duration of specification. :paramtype blob_duration: str """ - super(LogSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.blob_duration = blob_duration -class ManagedHsmResource(msrest.serialization.Model): +class ManagedHsmResource(_serialization.Model): """Managed HSM resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -980,7 +919,7 @@ class ManagedHsmResource(msrest.serialization.Model): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -988,20 +927,20 @@ class ManagedHsmResource(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'system_data': {'readonly': True}, + "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'}, + "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__( @@ -1017,10 +956,10 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :keyword tags: Resource tags. :paramtype tags: dict[str, str] """ - super(ManagedHsmResource, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -1045,7 +984,7 @@ class ManagedHsm(ManagedHsmResource): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -1055,21 +994,21 @@ class ManagedHsm(ManagedHsmResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'system_data': {'readonly': True}, + "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'}, + "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__( @@ -1086,16 +1025,16 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :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(ManagedHsm, self).__init__(location=location, sku=sku, tags=tags, **kwargs) + super().__init__(location=location, sku=sku, tags=tags, **kwargs) self.properties = properties -class ManagedHsmError(msrest.serialization.Model): +class ManagedHsmError(_serialization.Model): """The error exception. Variables are only populated by the server, and will be ignored when sending a request. @@ -1105,24 +1044,20 @@ class ManagedHsmError(msrest.serialization.Model): """ _validation = { - 'error': {'readonly': True}, + "error": {"readonly": True}, } _attribute_map = { - 'error': {'key': 'error', 'type': 'Error'}, + "error": {"key": "error", "type": "Error"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(ManagedHsmError, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.error = None -class ManagedHsmListResult(msrest.serialization.Model): +class ManagedHsmListResult(_serialization.Model): """List of managed HSM Pools. :ivar value: The list of managed HSM Pools. @@ -1132,16 +1067,12 @@ class ManagedHsmListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[ManagedHsm]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.ManagedHsm"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of managed HSM Pools. @@ -1149,12 +1080,12 @@ def __init__( :keyword next_link: The URL to get the next set of managed HSM Pools. :paramtype next_link: str """ - super(ManagedHsmListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class ManagedHsmProperties(msrest.serialization.Model): +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. @@ -1181,12 +1112,12 @@ class ManagedHsmProperties(msrest.serialization.Model): 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", "default". + 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", "Restoring". + "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. @@ -1196,7 +1127,7 @@ class ManagedHsmProperties(msrest.serialization.Model): :vartype private_endpoint_connections: list[~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnectionItem] :ivar public_network_access: Control permission for data plane traffic coming from public - networks while private endpoint is enabled. Known values are: "Enabled", "Disabled". + networks while private endpoint is enabled. 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. @@ -1204,27 +1135,30 @@ class ManagedHsmProperties(msrest.serialization.Model): """ _validation = { - 'hsm_uri': {'readonly': True}, - 'status_message': {'readonly': True}, - 'provisioning_state': {'readonly': True}, - 'private_endpoint_connections': {'readonly': True}, - 'scheduled_purge_date': {'readonly': True}, + "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'}, + "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__( @@ -1232,9 +1166,9 @@ def __init__( *, tenant_id: Optional[str] = None, initial_admin_object_ids: Optional[List[str]] = None, - enable_soft_delete: Optional[bool] = True, - soft_delete_retention_in_days: Optional[int] = 90, - enable_purge_protection: Optional[bool] = True, + 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: Optional[Union[str, "_models.PublicNetworkAccess"]] = None, @@ -1262,17 +1196,17 @@ def __init__( 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", "default". + 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 for data plane traffic coming from public - networks while private endpoint is enabled. Known values are: "Enabled", "Disabled". + networks while private endpoint is enabled. Known values are: "Enabled" and "Disabled". :paramtype public_network_access: str or ~azure.mgmt.keyvault.v2021_10_01.models.PublicNetworkAccess """ - super(ManagedHsmProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.initial_admin_object_ids = initial_admin_object_ids self.hsm_uri = None @@ -1288,48 +1222,48 @@ def __init__( self.scheduled_purge_date = None -class ManagedHsmSku(msrest.serialization.Model): +class ManagedHsmSku(_serialization.Model): """SKU details. All required parameters must be populated in order to send to Azure. - :ivar family: Required. SKU Family of the managed HSM Pool. Known values are: "B". + :ivar family: SKU Family of the managed HSM Pool. Required. "B" :vartype family: str or ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSkuFamily - :ivar name: Required. SKU of the managed HSM Pool. Known values are: "Standard_B1", + :ivar name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1" and "Custom_B32". :vartype name: str or ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSkuName """ _validation = { - 'family': {'required': True}, - 'name': {'required': True}, + "family": {"required": True}, + "name": {"required": True}, } _attribute_map = { - 'family': {'key': 'family', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, + "family": {"key": "family", "type": "str"}, + "name": {"key": "name", "type": "str"}, } def __init__( self, *, - family: Union[str, "_models.ManagedHsmSkuFamily"] = "B", + family: Union[str, "_models.ManagedHsmSkuFamily"], name: Union[str, "_models.ManagedHsmSkuName"], **kwargs ): """ - :keyword family: Required. SKU Family of the managed HSM Pool. Known values are: "B". + :keyword family: SKU Family of the managed HSM Pool. Required. "B" :paramtype family: str or ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSkuFamily - :keyword name: Required. SKU of the managed HSM Pool. Known values are: "Standard_B1", + :keyword name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1" and "Custom_B32". :paramtype name: str or ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSkuName """ - super(ManagedHsmSku, self).__init__(**kwargs) + super().__init__(**kwargs) self.family = family self.name = name -class MetricSpecification(msrest.serialization.Model): +class MetricSpecification(_serialization.Model): # pylint: disable=too-many-instance-attributes """Metric specification of operation. :ivar name: Name of metric specification. @@ -1358,17 +1292,17 @@ class MetricSpecification(msrest.serialization.Model): """ _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'}, + "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__( @@ -1412,7 +1346,7 @@ def __init__( :keyword internal_metric_name: The internal metric name. :paramtype internal_metric_name: str """ - super(MetricSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.display_description = display_description @@ -1426,49 +1360,44 @@ def __init__( self.internal_metric_name = internal_metric_name -class MHSMIPRule(msrest.serialization.Model): +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 Azure. - :ivar value: Required. 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). + :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}, + "value": {"required": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, + "value": {"key": "value", "type": "str"}, } - def __init__( - self, - *, - value: str, - **kwargs - ): + def __init__(self, *, value: str, **kwargs): """ - :keyword value: Required. 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). + :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(MHSMIPRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class MHSMNetworkRuleSet(msrest.serialization.Model): +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", + '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", "Deny". + "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] @@ -1478,10 +1407,10 @@ class MHSMNetworkRuleSet(msrest.serialization.Model): """ _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]'}, + "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__( @@ -1495,12 +1424,12 @@ 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", + '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", "Deny". + 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] @@ -1508,14 +1437,14 @@ def __init__( :paramtype virtual_network_rules: list[~azure.mgmt.keyvault.v2021_10_01.models.MHSMVirtualNetworkRule] """ - super(MHSMNetworkRuleSet, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class MHSMPrivateEndpoint(_serialization.Model): """Private endpoint object properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -1525,24 +1454,20 @@ class MHSMPrivateEndpoint(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, + "id": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(MHSMPrivateEndpoint, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None -class MHSMPrivateEndpointConnection(ManagedHsmResource): +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. @@ -1557,7 +1482,7 @@ class MHSMPrivateEndpointConnection(ManagedHsmResource): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -1570,30 +1495,33 @@ class MHSMPrivateEndpointConnection(ManagedHsmResource): :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", "Disconnected". + 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}, + "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'}, + "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__( @@ -1613,7 +1541,7 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :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 @@ -1623,18 +1551,18 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnectionProvisioningState """ - super(MHSMPrivateEndpointConnection, self).__init__(location=location, sku=sku, tags=tags, **kwargs) + 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(msrest.serialization.Model): +class MHSMPrivateEndpointConnectionItem(_serialization.Model): """Private endpoint connection item. :ivar id: Id of private endpoint connection. @@ -1647,23 +1575,26 @@ class MHSMPrivateEndpointConnectionItem(msrest.serialization.Model): :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", "Disconnected". + 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'}, + "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, + 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, @@ -1681,11 +1612,11 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnectionProvisioningState """ - super(MHSMPrivateEndpointConnectionItem, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id self.etag = etag self.private_endpoint = private_endpoint @@ -1693,7 +1624,7 @@ def __init__( self.provisioning_state = provisioning_state -class MHSMPrivateEndpointConnectionsListResult(msrest.serialization.Model): +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. @@ -1703,8 +1634,8 @@ class MHSMPrivateEndpointConnectionsListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[MHSMPrivateEndpointConnection]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[MHSMPrivateEndpointConnection]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( @@ -1720,7 +1651,7 @@ def __init__( :keyword next_link: The URL to get the next set of managed HSM Pools. :paramtype next_link: str """ - super(MHSMPrivateEndpointConnectionsListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link @@ -1740,7 +1671,7 @@ class MHSMPrivateLinkResource(ManagedHsmResource): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -1754,25 +1685,25 @@ class MHSMPrivateLinkResource(ManagedHsmResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'system_data': {'readonly': True}, - 'group_id': {'readonly': True}, - 'required_members': {'readonly': True}, + "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]'}, + "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__( @@ -1789,18 +1720,18 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :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(MHSMPrivateLinkResource, self).__init__(location=location, sku=sku, tags=tags, **kwargs) + 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(msrest.serialization.Model): +class MHSMPrivateLinkResourceListResult(_serialization.Model): """A list of private link resources. :ivar value: Array of private link resources. @@ -1808,41 +1739,36 @@ class MHSMPrivateLinkResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[MHSMPrivateLinkResource]'}, + "value": {"key": "value", "type": "[MHSMPrivateLinkResource]"}, } - def __init__( - self, - *, - value: Optional[List["_models.MHSMPrivateLinkResource"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.MHSMPrivateLinkResource"]] = None, **kwargs): """ :keyword value: Array of private link resources. :paramtype value: list[~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateLinkResource] """ - super(MHSMPrivateLinkResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class MHSMPrivateLinkServiceConnectionState(msrest.serialization.Model): +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", "Disconnected". + 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. Known values are: "None". + 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'}, + "status": {"key": "status", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "actions_required": {"key": "actionsRequired", "type": "str"}, } def __init__( @@ -1855,64 +1781,61 @@ 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", "Disconnected". + 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. Known values are: "None". + updates on the consumer. "None" :paramtype actions_required: str or ~azure.mgmt.keyvault.v2021_10_01.models.ActionsRequired """ - super(MHSMPrivateLinkServiceConnectionState, self).__init__(**kwargs) + super().__init__(**kwargs) self.status = status self.description = description self.actions_required = actions_required -class MHSMVirtualNetworkRule(msrest.serialization.Model): +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 Azure. - :ivar id: Required. Full resource id of a vnet subnet, such as + :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}, + "id": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - *, - id: str, - **kwargs - ): + def __init__(self, *, id: str, **kwargs): # pylint: disable=redefined-builtin """ - :keyword id: Required. Full resource id of a vnet subnet, such as + :keyword id: Full resource id of a vnet subnet, such as '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. + Required. :paramtype id: str """ - super(MHSMVirtualNetworkRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id -class NetworkRuleSet(msrest.serialization.Model): +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", + '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", "Deny". + "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] @@ -1922,10 +1845,10 @@ class NetworkRuleSet(msrest.serialization.Model): """ _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]'}, + "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__( @@ -1939,12 +1862,12 @@ 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", + '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", "Deny". + 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] @@ -1952,14 +1875,14 @@ def __init__( :paramtype virtual_network_rules: list[~azure.mgmt.keyvault.v2021_10_01.models.VirtualNetworkRule] """ - super(NetworkRuleSet, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class Operation(_serialization.Model): """Key Vault REST API operation definition. :ivar name: Operation name: {provider}/{resource}/{operation}. @@ -1975,11 +1898,11 @@ class Operation(msrest.serialization.Model): """ _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'}, + "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__( @@ -2004,7 +1927,7 @@ def __init__( :keyword service_specification: One property of operation, include metric specifications. :paramtype service_specification: ~azure.mgmt.keyvault.v2021_10_01.models.ServiceSpecification """ - super(Operation, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display = display self.origin = origin @@ -2012,7 +1935,7 @@ def __init__( self.service_specification = service_specification -class OperationDisplay(msrest.serialization.Model): +class OperationDisplay(_serialization.Model): """Display metadata associated with the operation. :ivar provider: Service provider: Microsoft Key Vault. @@ -2026,10 +1949,10 @@ class OperationDisplay(msrest.serialization.Model): """ _attribute_map = { - 'provider': {'key': 'provider', 'type': 'str'}, - 'resource': {'key': 'resource', 'type': 'str'}, - 'operation': {'key': 'operation', 'type': 'str'}, - 'description': {'key': 'description', 'type': 'str'}, + "provider": {"key": "provider", "type": "str"}, + "resource": {"key": "resource", "type": "str"}, + "operation": {"key": "operation", "type": "str"}, + "description": {"key": "description", "type": "str"}, } def __init__( @@ -2051,14 +1974,14 @@ def __init__( :keyword description: Description of operation. :paramtype description: str """ - super(OperationDisplay, self).__init__(**kwargs) + super().__init__(**kwargs) self.provider = provider self.resource = resource self.operation = operation self.description = description -class OperationListResult(msrest.serialization.Model): +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. @@ -2068,29 +1991,23 @@ class OperationListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Operation]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(OperationListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class Permissions(msrest.serialization.Model): +class Permissions(_serialization.Model): """Permissions the identity has for keys, secrets, certificates and storage. :ivar keys: Permissions to keys. @@ -2105,10 +2022,10 @@ class Permissions(msrest.serialization.Model): """ _attribute_map = { - 'keys': {'key': 'keys', 'type': '[str]'}, - 'secrets': {'key': 'secrets', 'type': '[str]'}, - 'certificates': {'key': 'certificates', 'type': '[str]'}, - 'storage': {'key': 'storage', 'type': '[str]'}, + "keys": {"key": "keys", "type": "[str]"}, + "secrets": {"key": "secrets", "type": "[str]"}, + "certificates": {"key": "certificates", "type": "[str]"}, + "storage": {"key": "storage", "type": "[str]"}, } def __init__( @@ -2131,14 +2048,14 @@ def __init__( :keyword storage: Permissions to storage accounts. :paramtype storage: list[str or ~azure.mgmt.keyvault.v2021_10_01.models.StoragePermissions] """ - super(Permissions, self).__init__(**kwargs) + super().__init__(**kwargs) self.keys = keys self.secrets = secrets self.certificates = certificates self.storage = storage -class PrivateEndpoint(msrest.serialization.Model): +class PrivateEndpoint(_serialization.Model): """Private endpoint object properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -2148,20 +2065,16 @@ class PrivateEndpoint(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, + "id": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(PrivateEndpoint, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None @@ -2178,7 +2091,7 @@ class PrivateEndpointConnection(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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 @@ -2188,29 +2101,32 @@ class PrivateEndpointConnection(Resource): :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", "Disconnected". + 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}, + "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'}, + "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__( @@ -2231,18 +2147,18 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnectionProvisioningState """ - super(PrivateEndpointConnection, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class PrivateEndpointConnectionItem(_serialization.Model): """Private endpoint connection item. :ivar id: Id of private endpoint connection. @@ -2255,23 +2171,26 @@ class PrivateEndpointConnectionItem(msrest.serialization.Model): :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", "Disconnected". + 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'}, + "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, + 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, @@ -2289,11 +2208,11 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnectionProvisioningState """ - super(PrivateEndpointConnectionItem, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id self.etag = etag self.private_endpoint = private_endpoint @@ -2301,7 +2220,7 @@ def __init__( self.provisioning_state = provisioning_state -class PrivateEndpointConnectionListResult(msrest.serialization.Model): +class PrivateEndpointConnectionListResult(_serialization.Model): """List of private endpoint connections. :ivar value: The list of private endpoint connections. @@ -2311,8 +2230,8 @@ class PrivateEndpointConnectionListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[PrivateEndpointConnection]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[PrivateEndpointConnection]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( @@ -2328,7 +2247,7 @@ def __init__( :keyword next_link: The URL to get the next set of private endpoint connections. :paramtype next_link: str """ - super(PrivateEndpointConnectionListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link @@ -2346,7 +2265,7 @@ class PrivateLinkResource(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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 @@ -2357,43 +2276,38 @@ class PrivateLinkResource(Resource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'location': {'readonly': True}, - 'tags': {'readonly': True}, - 'group_id': {'readonly': True}, - 'required_members': {'readonly': True}, + "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]'}, + "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 - ): + def __init__(self, *, required_zone_names: Optional[List[str]] = None, **kwargs): """ :keyword required_zone_names: Required DNS zone names of the the private link resource. :paramtype required_zone_names: list[str] """ - super(PrivateLinkResource, self).__init__(**kwargs) + super().__init__(**kwargs) self.group_id = None self.required_members = None self.required_zone_names = required_zone_names -class PrivateLinkResourceListResult(msrest.serialization.Model): +class PrivateLinkResourceListResult(_serialization.Model): """A list of private link resources. :ivar value: Array of private link resources. @@ -2401,41 +2315,36 @@ class PrivateLinkResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[PrivateLinkResource]'}, + "value": {"key": "value", "type": "[PrivateLinkResource]"}, } - def __init__( - self, - *, - value: Optional[List["_models.PrivateLinkResource"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs): """ :keyword value: Array of private link resources. :paramtype value: list[~azure.mgmt.keyvault.v2021_10_01.models.PrivateLinkResource] """ - super(PrivateLinkResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class PrivateLinkServiceConnectionState(msrest.serialization.Model): +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", "Disconnected". + 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. Known values are: "None". + 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'}, + "status": {"key": "status", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "actions_required": {"key": "actionsRequired", "type": "str"}, } def __init__( @@ -2448,22 +2357,22 @@ 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", "Disconnected". + 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. Known values are: "None". + updates on the consumer. "None" :paramtype actions_required: str or ~azure.mgmt.keyvault.v2021_10_01.models.ActionsRequired """ - super(PrivateLinkServiceConnectionState, self).__init__(**kwargs) + super().__init__(**kwargs) self.status = status self.description = description self.actions_required = actions_required -class ResourceListResult(msrest.serialization.Model): +class ResourceListResult(_serialization.Model): """List of vault resources. :ivar value: The list of vault resources. @@ -2473,24 +2382,18 @@ class ResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Resource]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Resource"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(ResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link @@ -2510,41 +2413,36 @@ class Secret(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :ivar tags: Tags assigned to the key vault resource. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the secret. + :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}, + "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'}, + "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 - ): + def __init__(self, *, properties: "_models.SecretProperties", **kwargs): """ - :keyword properties: Required. Properties of the secret. + :keyword properties: Properties of the secret. Required. :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.SecretProperties """ - super(Secret, self).__init__(**kwargs) + super().__init__(**kwargs) self.properties = properties @@ -2566,16 +2464,16 @@ class SecretAttributes(Attributes): """ _validation = { - 'created': {'readonly': True}, - 'updated': {'readonly': True}, + "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'}, + "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__( @@ -2594,48 +2492,42 @@ def __init__( :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. :paramtype expires: ~datetime.datetime """ - super(SecretAttributes, self).__init__(enabled=enabled, not_before=not_before, expires=expires, **kwargs) + super().__init__(enabled=enabled, not_before=not_before, expires=expires, **kwargs) -class SecretCreateOrUpdateParameters(msrest.serialization.Model): +class SecretCreateOrUpdateParameters(_serialization.Model): """Parameters for creating or updating a secret. All required parameters must be populated in order to send to Azure. - :ivar tags: A set of tags. The tags that will be assigned to the secret. + :ivar tags: The tags that will be assigned to the secret. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the secret. + :ivar properties: Properties of the secret. Required. :vartype properties: ~azure.mgmt.keyvault.v2021_10_01.models.SecretProperties """ _validation = { - 'properties': {'required': True}, + "properties": {"required": True}, } _attribute_map = { - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'SecretProperties'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "SecretProperties"}, } - def __init__( - self, - *, - properties: "_models.SecretProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs - ): + def __init__(self, *, properties: "_models.SecretProperties", tags: Optional[Dict[str, str]] = None, **kwargs): """ - :keyword tags: A set of tags. The tags that will be assigned to the secret. + :keyword tags: The tags that will be assigned to the secret. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the secret. + :keyword properties: Properties of the secret. Required. :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.SecretProperties """ - super(SecretCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class SecretListResult(msrest.serialization.Model): +class SecretListResult(_serialization.Model): """List of secrets. :ivar value: The list of secrets. @@ -2645,40 +2537,34 @@ class SecretListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Secret]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Secret"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(SecretListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class SecretPatchParameters(msrest.serialization.Model): +class SecretPatchParameters(_serialization.Model): """Parameters for patching a secret. - :ivar tags: A set of tags. The tags that will be assigned to the 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'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "SecretPatchProperties"}, } def __init__( @@ -2689,17 +2575,17 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. The tags that will be assigned to the secret. + :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(SecretPatchParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class SecretPatchProperties(msrest.serialization.Model): +class SecretPatchProperties(_serialization.Model): """Properties of the secret. :ivar value: The value of the secret. @@ -2711,9 +2597,9 @@ class SecretPatchProperties(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, - 'content_type': {'key': 'contentType', 'type': 'str'}, - 'attributes': {'key': 'attributes', 'type': 'SecretAttributes'}, + "value": {"key": "value", "type": "str"}, + "content_type": {"key": "contentType", "type": "str"}, + "attributes": {"key": "attributes", "type": "SecretAttributes"}, } def __init__( @@ -2732,13 +2618,13 @@ def __init__( :keyword attributes: The attributes of the secret. :paramtype attributes: ~azure.mgmt.keyvault.v2021_10_01.models.SecretAttributes """ - super(SecretPatchProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.content_type = content_type self.attributes = attributes -class SecretProperties(msrest.serialization.Model): +class SecretProperties(_serialization.Model): """Properties of the secret. Variables are only populated by the server, and will be ignored when sending a request. @@ -2758,16 +2644,16 @@ class SecretProperties(msrest.serialization.Model): """ _validation = { - 'secret_uri': {'readonly': True}, - 'secret_uri_with_version': {'readonly': True}, + "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'}, + "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__( @@ -2788,7 +2674,7 @@ def __init__( :keyword attributes: The attributes of the secret. :paramtype attributes: ~azure.mgmt.keyvault.v2021_10_01.models.SecretAttributes """ - super(SecretProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.content_type = content_type self.attributes = attributes @@ -2796,7 +2682,7 @@ def __init__( self.secret_uri_with_version = None -class ServiceSpecification(msrest.serialization.Model): +class ServiceSpecification(_serialization.Model): """One property of operation, include log specifications. :ivar log_specifications: Log specifications of operation. @@ -2807,8 +2693,8 @@ class ServiceSpecification(msrest.serialization.Model): """ _attribute_map = { - 'log_specifications': {'key': 'logSpecifications', 'type': '[LogSpecification]'}, - 'metric_specifications': {'key': 'metricSpecifications', 'type': '[MetricSpecification]'}, + "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, + "metric_specifications": {"key": "metricSpecifications", "type": "[MetricSpecification]"}, } def __init__( @@ -2825,78 +2711,72 @@ def __init__( :paramtype metric_specifications: list[~azure.mgmt.keyvault.v2021_10_01.models.MetricSpecification] """ - super(ServiceSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.log_specifications = log_specifications self.metric_specifications = metric_specifications -class Sku(msrest.serialization.Model): +class Sku(_serialization.Model): """SKU details. All required parameters must be populated in order to send to Azure. - :ivar family: Required. SKU family name. Known values are: "A". + :ivar family: SKU family name. Required. "A" :vartype family: str or ~azure.mgmt.keyvault.v2021_10_01.models.SkuFamily - :ivar name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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}, + "family": {"required": True}, + "name": {"required": True}, } _attribute_map = { - 'family': {'key': 'family', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, + "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 - ): + def __init__(self, *, family: Union[str, "_models.SkuFamily"], name: Union[str, "_models.SkuName"], **kwargs): """ - :keyword family: Required. SKU family name. Known values are: "A". + :keyword family: SKU family name. Required. "A" :paramtype family: str or ~azure.mgmt.keyvault.v2021_10_01.models.SkuFamily - :keyword name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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(Sku, self).__init__(**kwargs) + super().__init__(**kwargs) self.family = family self.name = name -class SystemData(msrest.serialization.Model): +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", "Key". + 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", "Key". + 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'}, + "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__( @@ -2914,19 +2794,19 @@ def __init__( :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", "Key". + 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", "Key". + 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(SystemData, self).__init__(**kwargs) + super().__init__(**kwargs) self.created_by = created_by self.created_by_type = created_by_type self.created_at = created_at @@ -2935,7 +2815,7 @@ def __init__( self.last_modified_at = last_modified_at -class Vault(msrest.serialization.Model): +class Vault(_serialization.Model): """Resource information with extended details. Variables are only populated by the server, and will be ignored when sending a request. @@ -2950,30 +2830,30 @@ class Vault(msrest.serialization.Model): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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: Required. Properties of the vault. + :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}, + "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'}, + "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__( @@ -2987,12 +2867,12 @@ def __init__( """ :keyword location: Azure location of the key vault resource. :paramtype location: str - :keyword tags: A set of tags. Tags assigned to the key vault resource. + :keyword tags: Tags assigned to the key vault resource. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.VaultProperties """ - super(Vault, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -3002,7 +2882,7 @@ def __init__( self.properties = properties -class VaultAccessPolicyParameters(msrest.serialization.Model): +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. @@ -3017,37 +2897,32 @@ class VaultAccessPolicyParameters(msrest.serialization.Model): :vartype type: str :ivar location: The resource type of the access policy. :vartype location: str - :ivar properties: Required. Properties of the access policy. + :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}, + "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'}, + "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 - ): + def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs): """ - :keyword properties: Required. Properties of the access policy. + :keyword properties: Properties of the access policy. Required. :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyProperties """ - super(VaultAccessPolicyParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -3055,127 +2930,112 @@ def __init__( self.properties = properties -class VaultAccessPolicyProperties(msrest.serialization.Model): +class VaultAccessPolicyProperties(_serialization.Model): """Properties of the vault access policy. All required parameters must be populated in order to send to Azure. - :ivar access_policies: Required. 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. + :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}, + "access_policies": {"required": True}, } _attribute_map = { - 'access_policies': {'key': 'accessPolicies', 'type': '[AccessPolicyEntry]'}, + "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, } - def __init__( - self, - *, - access_policies: List["_models.AccessPolicyEntry"], - **kwargs - ): + def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwargs): """ - :keyword access_policies: Required. 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. + :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(VaultAccessPolicyProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.access_policies = access_policies -class VaultCheckNameAvailabilityParameters(msrest.serialization.Model): +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 Azure. - :ivar name: Required. The vault name. + :ivar name: The vault name. Required. :vartype name: str - :ivar type: The type of resource, Microsoft.KeyVault/vaults. Has constant value: + :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}, + "name": {"required": True}, + "type": {"required": True, "constant": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, } type = "Microsoft.KeyVault/vaults" - def __init__( - self, - *, - name: str, - **kwargs - ): + def __init__(self, *, name: str, **kwargs): """ - :keyword name: Required. The vault name. + :keyword name: The vault name. Required. :paramtype name: str """ - super(VaultCheckNameAvailabilityParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name -class VaultCreateOrUpdateParameters(msrest.serialization.Model): +class VaultCreateOrUpdateParameters(_serialization.Model): """Parameters for creating or updating a vault. All required parameters must be populated in order to send to Azure. - :ivar location: Required. The supported Azure location where the key vault should be created. + :ivar location: The supported Azure location where the key vault should be created. Required. :vartype location: str - :ivar tags: A set of tags. The tags that will be assigned to the key vault. + :ivar tags: The tags that will be assigned to the key vault. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the vault. + :ivar properties: Properties of the vault. Required. :vartype properties: ~azure.mgmt.keyvault.v2021_10_01.models.VaultProperties """ _validation = { - 'location': {'required': True}, - 'properties': {'required': True}, + "location": {"required": True}, + "properties": {"required": True}, } _attribute_map = { - 'location': {'key': 'location', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'VaultProperties'}, + "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 + self, *, location: str, properties: "_models.VaultProperties", tags: Optional[Dict[str, str]] = None, **kwargs ): """ - :keyword location: Required. The supported Azure location where the key vault should be - created. + :keyword location: The supported Azure location where the key vault should be created. + Required. :paramtype location: str - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :keyword tags: The tags that will be assigned to the key vault. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2021_10_01.models.VaultProperties """ - super(VaultCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.location = location self.tags = tags self.properties = properties -class VaultListResult(msrest.serialization.Model): +class VaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of vaults. @@ -3185,40 +3045,34 @@ class VaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Vault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Vault"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(VaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class VaultPatchParameters(msrest.serialization.Model): +class VaultPatchParameters(_serialization.Model): """Parameters for creating or updating a vault. - :ivar tags: A set of tags. The tags that will be assigned to the key 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'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "VaultPatchProperties"}, } def __init__( @@ -3229,17 +3083,17 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :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(VaultPatchParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class VaultPatchProperties(msrest.serialization.Model): +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 @@ -3272,7 +3126,7 @@ class VaultPatchProperties(msrest.serialization.Model): :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", "default". + 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 @@ -3291,19 +3145,19 @@ class VaultPatchProperties(msrest.serialization.Model): """ _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'}, + "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__( @@ -3356,7 +3210,7 @@ def __init__( <=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", "default". + 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 @@ -3373,7 +3227,7 @@ def __init__( meaning that even if the firewall rules are present we will not honor the rules. :paramtype public_network_access: str """ - super(VaultPatchProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies @@ -3389,17 +3243,17 @@ def __init__( self.public_network_access = public_network_access -class VaultProperties(msrest.serialization.Model): +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 Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :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 @@ -3433,7 +3287,7 @@ class VaultProperties(msrest.serialization.Model): 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", "default". + 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 @@ -3444,7 +3298,7 @@ class VaultProperties(msrest.serialization.Model): :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", + :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 @@ -3460,30 +3314,33 @@ class VaultProperties(msrest.serialization.Model): """ _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'}, + "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__( @@ -3496,21 +3353,21 @@ def __init__( 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] = True, - soft_delete_retention_in_days: Optional[int] = 90, - enable_rbac_authorization: Optional[bool] = False, + 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: Optional[str] = "enabled", + public_network_access: str = "enabled", **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :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 @@ -3543,7 +3400,7 @@ def __init__( 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", "default". + 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 @@ -3554,7 +3411,7 @@ def __init__( :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", + :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 @@ -3564,7 +3421,7 @@ def __init__( meaning that even if the firewall rules are present we will not honor the rules. :paramtype public_network_access: str """ - super(VaultProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies @@ -3584,13 +3441,14 @@ def __init__( self.public_network_access = public_network_access -class VirtualNetworkRule(msrest.serialization.Model): +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 Azure. - :ivar id: Required. Full resource id of a vnet subnet, such as + :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. @@ -3598,29 +3456,30 @@ class VirtualNetworkRule(msrest.serialization.Model): """ _validation = { - 'id': {'required': True}, + "id": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'ignore_missing_vnet_service_endpoint': {'key': 'ignoreMissingVnetServiceEndpoint', 'type': 'bool'}, + "id": {"key": "id", "type": "str"}, + "ignore_missing_vnet_service_endpoint": {"key": "ignoreMissingVnetServiceEndpoint", "type": "bool"}, } def __init__( self, *, - id: str, + id: str, # pylint: disable=redefined-builtin ignore_missing_vnet_service_endpoint: Optional[bool] = None, **kwargs ): """ - :keyword id: Required. Full resource id of a vnet subnet, such as + :keyword id: Full resource id of a vnet subnet, such as '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. + 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(VirtualNetworkRule, self).__init__(**kwargs) + 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index 49be258e3efc..9e5cd053e465 100644 --- 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 @@ -19,16 +19,17 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'KeysOperations', - 'VaultsOperations', - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'ManagedHsmsOperations', - 'MHSMPrivateEndpointConnectionsOperations', - 'MHSMPrivateLinkResourcesOperations', - 'Operations', - 'SecretsOperations', + "KeysOperations", + "VaultsOperations", + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "ManagedHsmsOperations", + "MHSMPrivateEndpointConnectionsOperations", + "MHSMPrivateLinkResourcesOperations", + "Operations", + "SecretsOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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 index 56b4aad1b518..2101f8924a6f 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -20,214 +26,176 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - *, - json: Optional[_models.KeyCreateParameters] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_version_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - key_version: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_versions_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class KeysOperations: """ @@ -248,14 +216,15 @@ def __init__(self, *args, **kwargs): 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") - - @distributed_trace + @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 @@ -263,42 +232,126 @@ def create_if_not_exist( subsequent versions, and does not update existing keys. :param resource_group_name: The name of the resource group which contains the specified key - vault. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. + :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. + :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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_if_not_exist( + self, + resource_group_name: str, + vault_name: str, + key_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a + IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.KeyCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Key or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - _json = self._serialize.body(parameters, 'KeyCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "KeyCreateParameters") request = build_create_if_not_exist_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.create_if_not_exist.metadata['url'], + content=_content, + template_url=self.create_if_not_exist.metadata["url"], headers=_headers, params=_params, ) @@ -306,67 +359,61 @@ def create_if_not_exist( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_if_not_exist.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + create_if_not_exist.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> _models.Key: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. + :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. + :param key_name: The name of the key to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -374,64 +421,61 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace - def list( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> Iterable[_models.KeyListResult]: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. + :param vault_name: The name of the vault which contains the keys to be retrieved. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -439,15 +483,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -464,10 +510,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -477,57 +521,53 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore @distributed_trace def get_version( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - key_version: str, - **kwargs: Any + 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. + 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. + :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. + :param key_version: The version of the key to be retrieved. Required. :type key_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_version_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get_version.metadata['url'], + template_url=self.get_version.metadata["url"], headers=_headers, params=_params, ) @@ -535,68 +575,67 @@ def get_version( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_version.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore - + get_version.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore @distributed_trace def list_versions( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> Iterable[_models.KeyListResult]: + 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. + 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. + :param key_name: The name of the key versions to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_versions_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_versions.metadata['url'], + template_url=self.list_versions.metadata["url"], headers=_headers, params=_params, ) @@ -604,16 +643,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_versions_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -630,10 +670,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -643,8 +681,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_versions.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore + list_versions.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore 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 index 575428dd5d13..aad1245bc62f 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,358 +28,281 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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_initial( - resource_group_name: str, - name: str, - subscription_id: str, - *, - json: Optional[_models.ManagedHsm] = None, - content: Any = None, - **kwargs: Any + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) - - -def build_update_request_initial( - resource_group_name: str, - name: str, - subscription_id: str, - *, - json: Optional[_models.ManagedHsm] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) - - -def build_delete_request_initial( - resource_group_name: str, - name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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["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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_list_deleted_request( - subscription_id: str, - **kwargs: Any -) -> HttpRequest: +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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["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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "name": _SERIALIZER.url("name", name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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_initial( - name: str, - location: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "name": _SERIALIZER.url("name", name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class ManagedHsmsOperations: """ @@ -394,36 +323,41 @@ def __init__(self, *args, **kwargs): 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") - def _create_or_update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -431,46 +365,51 @@ def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - @distributed_trace + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. + :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 :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -481,20 +420,82 @@ def begin_create_or_update( Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], **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 model type + or a IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -502,69 +503,71 @@ def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore def _update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_update_request_initial( + 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, - template_url=self._update_initial.metadata['url'], + content=_content, + template_url=self._update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -572,49 +575,54 @@ def _update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + 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 = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - - deserialized = self._deserialize('ManagedHsm', pipeline_response) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + _update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - - @distributed_trace + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to patch the managed HSM Pool. + :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 :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -625,20 +633,82 @@ def begin_update( Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def begin_update( + self, + resource_group_name: str, + name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._update_initial( # type: ignore resource_group_name=resource_group_name, @@ -646,64 +716,59 @@ def begin_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore def _delete_initial( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any + self, resource_group_name: str, name: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_delete_request_initial( + request = build_delete_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -711,34 +776,29 @@ def _delete_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **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) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace - def begin_delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param name: The name of the managed HSM Pool to delete. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -750,92 +810,83 @@ def begin_delete( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore resource_group_name=resource_group_name, name=name, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> Optional[_models.ManagedHsm]: + 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. + :param name: The name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ManagedHsm, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.ManagedHsm]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.ManagedHsm]] - request = build_get_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -843,10 +894,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -856,56 +906,55 @@ def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -913,15 +962,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -938,10 +989,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -952,48 +1001,44 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -1001,14 +1046,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1025,10 +1073,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1039,44 +1085,41 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> Iterable[_models.DeletedManagedHsmListResult]: + def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedManagedHsm"]: """The List operation gets information about the deleted managed HSMs associated with the subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedManagedHsmListResult or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.DeletedManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1084,13 +1127,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1107,10 +1154,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1121,48 +1166,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore @distributed_trace - def get_deleted( - self, - name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedManagedHsm: + 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. + :param name: The name of the deleted managed HSM. Required. :type name: str - :param location: The location of the deleted managed HSM. + :param location: The location of the deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedManagedHsm, or the result of cls(response) + :return: DeletedManagedHsm or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.DeletedManagedHsm - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsm] - request = build_get_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1170,10 +1210,9 @@ def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -1181,40 +1220,38 @@ def get_deleted( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DeletedManagedHsm', pipeline_response) + deserialized = self._deserialize("DeletedManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any + self, name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -1222,34 +1259,28 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore @distributed_trace - def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param name: The name of the soft-deleted managed HSM. Required. :type name: str - :param location: The location of the soft-deleted managed HSM. + :param location: The location of the soft-deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -1261,52 +1292,45 @@ def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._purge_deleted_initial( # type: ignore name=name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # 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 index 071dc770d774..3a7a9e9bbc3f 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,173 +28,151 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - subscription_id: str, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_put_request( - subscription_id: str, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - *, - json: Optional[_models.MHSMPrivateEndpointConnection] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) - - -def build_delete_request_initial( - subscription_id: str, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + _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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class MHSMPrivateEndpointConnectionsOperations: """ @@ -209,47 +193,48 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def list_by_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> Iterable[_models.MHSMPrivateEndpointConnectionsListResult]: + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either MHSMPrivateEndpointConnectionsListResult or the - result of cls(response) + :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.MHSMPrivateEndpointConnectionsListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -257,15 +242,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -282,10 +269,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -296,53 +281,50 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -350,10 +332,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -361,64 +342,142 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - @distributed_trace + @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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def put( + self, + resource_group_name: str, + name: str, + private_endpoint_connection_name: str, + properties: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: MHSMPrivateEndpointConnection or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - _json = self._serialize.body(properties, 'MHSMPrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -426,10 +485,9 @@ def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -437,45 +495,44 @@ def put( 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')) + 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) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore def _delete_initial( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.MHSMPrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -483,10 +540,9 @@ def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -496,37 +552,32 @@ def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def begin_delete( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -540,55 +591,48 @@ def begin_delete( result of cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 index caeeb7e5d52c..4a8315403c95 100644 --- 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 @@ -8,9 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,48 +24,46 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class MHSMPrivateLinkResourcesOperations: """ @@ -81,43 +84,42 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def list_by_mhsm_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateLinkResourceListResult, or the result of cls(response) + :return: MHSMPrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.MHSMPrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] - request = build_list_by_mhsm_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_mhsm_resource.metadata['url'], + template_url=self.list_by_mhsm_resource.metadata["url"], headers=_headers, params=_params, ) @@ -125,22 +127,20 @@ def list_by_mhsm_resource( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_mhsm_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # type: ignore - + list_by_mhsm_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # type: ignore 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/v2021_10_01/operations/_operations.py index d2219873fde6..9198f86c557b 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/v2021_10_01/operations/_operations.py @@ -7,10 +7,16 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +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.pipeline.transport import HttpResponse @@ -20,38 +26,34 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request -T = TypeVar('T') + +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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class Operations: """ @@ -72,36 +74,35 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> Iterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -109,12 +110,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -131,10 +137,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -144,8 +148,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index f90fd159ff3e..a97b62222b32 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,173 +28,163 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_put_request( - subscription_id: str, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, - *, - json: Optional[_models.PrivateEndpointConnection] = None, - content: Any = None, + subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) -def build_delete_request_initial( - subscription_id: str, +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_resource_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateEndpointConnectionsOperations: """ @@ -209,48 +205,45 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def get( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -258,10 +251,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -270,64 +262,139 @@ def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - @distributed_trace + @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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - _json = self._serialize.body(properties, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "PrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -335,10 +402,9 @@ def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -346,45 +412,44 @@ def put( 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')) + 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore def _delete_initial( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -392,10 +457,9 @@ def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -405,37 +469,31 @@ def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def begin_delete( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -449,99 +507,93 @@ def begin_delete( of cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2021_10_01.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def list_by_resource( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> Iterable[_models.PrivateEndpointConnectionListResult]: + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either PrivateEndpointConnectionListResult or the result - of cls(response) + :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.PrivateEndpointConnectionListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnectionListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -549,15 +601,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -574,10 +628,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -587,8 +639,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore 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/v2021_10_01/operations/_private_link_resources_operations.py index d7e77e34e18a..b18598ea80ab 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/v2021_10_01/operations/_private_link_resources_operations.py @@ -8,9 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,48 +24,46 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateLinkResourcesOperations: """ @@ -81,43 +84,41 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def list_by_vault( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateLinkResourceListResult, or the result of cls(response) + :return: PrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.PrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] - request = build_list_by_vault_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_vault.metadata['url'], + template_url=self.list_by_vault.metadata["url"], headers=_headers, params=_params, ) @@ -125,22 +126,20 @@ def list_by_vault( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_vault.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore - + list_by_vault.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore 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 index 1b12aa93d3b1..4f73f7f0ec55 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -20,185 +26,150 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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, - *, - json: Optional[_models.SecretCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + 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, - *, - json: Optional[_models.SecretPatchParameters] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class SecretsOperations: """ @@ -219,14 +190,15 @@ def __init__(self, *args, **kwargs): 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") - - @distributed_trace + @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 @@ -234,31 +206,115 @@ def create_or_update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.SecretCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -268,7 +324,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -276,10 +333,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -287,26 +343,27 @@ def create_or_update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - @distributed_trace + @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 @@ -314,31 +371,109 @@ def update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :param secret_name: Name of the secret. Required. :type secret_name: str - :param parameters: Parameters to patch the secret. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.SecretPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -348,7 +483,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -356,10 +492,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -367,60 +502,56 @@ def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - **kwargs: Any - ) -> _models.Secret: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param secret_name: The name of the secret. + :param secret_name: The name of the secret. Required. :type secret_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -428,69 +559,68 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace def list( - self, - resource_group_name: str, - vault_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.SecretListResult]: + 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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SecretListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.SecretListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SecretListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SecretListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, top=top, - template_url=self.list.metadata['url'], + api_version=api_version, + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -498,16 +628,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -524,10 +655,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -537,8 +666,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore 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/v2021_10_01/operations/_vaults_operations.py index c27fdc7a11fd..9abe397593be 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/v2021_10_01/operations/_vaults_operations.py @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,485 +28,377 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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_initial( - resource_group_name: str, - vault_name: str, - subscription_id: str, - *, - json: Optional[_models.VaultCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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, - *, - json: Optional[_models.VaultPatchParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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"], + operation_kind: Union[str, _models.AccessPolicyUpdateKind], subscription_id: str, - *, - json: Optional[_models.VaultAccessPolicyParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_purge_deleted_request_initial( - vault_name: str, - location: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + 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 + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - accept = _headers.pop('Accept', "application/json") + filter = kwargs.pop("filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') + _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') + _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 - ) + _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, - *, - json: Optional[_models.VaultCheckNameAvailabilityParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability") + _url = kwargs.pop( + "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability" + ) path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: """ @@ -521,36 +419,45 @@ def __init__(self, *args, **kwargs): 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") - def _create_or_update_initial( self, resource_group_name: str, vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **kwargs: Any ) -> _models.Vault: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -558,10 +465,9 @@ def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -569,35 +475,75 @@ def _create_or_update_initial( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + vault_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -608,20 +554,51 @@ def begin_create_or_update( Retry-After header is present. :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] - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -629,74 +606,140 @@ def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Vault + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update( + self, + resource_group_name: str, + vault_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def update( + self, + resource_group_name: str, + vault_name: str, + parameters: Union[_models.VaultPatchParameters, IO], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Vault + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -705,7 +748,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -713,10 +757,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -724,55 +767,54 @@ def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -780,10 +822,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -793,45 +834,42 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -839,63 +877,140 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - - @distributed_trace + @overload def update_access_policy( self, resource_group_name: str, vault_name: str, - operation_kind: Union[str, "_models.AccessPolicyUpdateKind"], + 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: VaultAccessPolicyParameters or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2021_10_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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: VaultAccessPolicyParameters or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.VaultAccessPolicyParameters + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -905,7 +1020,8 @@ def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -913,10 +1029,9 @@ def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -924,57 +1039,58 @@ def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -982,15 +1098,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1007,10 +1125,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1020,45 +1136,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -1066,14 +1180,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1090,10 +1207,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1103,43 +1218,40 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> Iterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1147,13 +1259,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1170,10 +1286,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1183,48 +1297,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace - def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1232,50 +1341,47 @@ def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -1283,10 +1389,9 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -1296,21 +1401,15 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace - def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -1322,62 +1421,51 @@ def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace - def list( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.ResourceListResult]: + 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. @@ -1390,31 +1478,36 @@ def list( that overriding this default value may result in unsupported behavior. :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2021_10_01.models.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + filter = kwargs.pop( + "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") + ) # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -1422,15 +1515,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1447,10 +1542,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1460,47 +1553,95 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace + @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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CheckNameAvailabilityResult or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.CheckNameAvailabilityResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def check_name_availability( + self, vault_name: IO, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CheckNameAvailabilityResult or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.CheckNameAvailabilityResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def check_name_availability( + self, vault_name: Union[_models.VaultCheckNameAvailabilityParameters, IO], **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 model type or a IO type. Required. :type vault_name: ~azure.mgmt.keyvault.v2021_10_01.models.VaultCheckNameAvailabilityParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2021_10_01.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2021-10-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1508,22 +1649,20 @@ def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore 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 index d19915ab3650..731fc6d4be82 100644 --- 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 @@ -17,7 +17,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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 index 78cc20decbaa..1ebc1d043df0 100644 --- 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 @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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: + def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2022-07-01") # type: str + api_version = kwargs.pop("api_version", "2022-07-01") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,23 +47,24 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) self._configure(**kwargs) def _configure( - self, - **kwargs # type: Any + self, **kwargs # type: Any ): # type: (...) -> 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.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs) + 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) + 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 index d39e64b6c8ae..5dec970770bc 100644 --- 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 @@ -9,20 +9,30 @@ from copy import deepcopy from typing import Any, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import HttpRequest, HttpResponse from azure.mgmt.core import ARMPipelineClient from . import models +from .._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration -from .operations import KeysOperations, MHSMPrivateEndpointConnectionsOperations, MHSMPrivateLinkResourcesOperations, ManagedHsmsOperations, Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, SecretsOperations, VaultsOperations +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=too-many-instance-attributes + +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. @@ -48,10 +58,10 @@ class KeyVaultManagementClient: # pylint: disable=too-many-instance-attribute :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. + :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. + 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 @@ -69,47 +79,34 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = ARMPipelineClient(base_url=base_url, config=self._config, **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 - ) - self.vaults = VaultsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize) + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) self.private_endpoint_connections = PrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.managed_hsms = ManagedHsmsOperations(self._client, self._config, self._serialize, self._deserialize) self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - self.secrets = SecretsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) + self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize) - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> HttpResponse: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -118,7 +115,7 @@ def _send_request( >>> response = client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 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 index b5d04d422c70..4a77ac1fd213 100644 --- 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 @@ -10,20 +10,20 @@ "azure_arm": true, "has_lro_operations": true, "client_side_validation": false, - "sync_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"ARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}", - "async_imports": "{\"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"], \"azure.core.credentials\": [\"TokenCredential\"]}}, \"regular\": {\"azurecore\": {\"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"], \"azure.mgmt.core\": [\"AsyncARMPipelineClient\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"]}, \"thirdparty\": {\"msrest\": [\"Deserializer\", \"Serializer\"]}}, \"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}}" + "sync_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"ARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \".._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials\": [\"TokenCredential\"]}}}", + "async_imports": "{\"conditional\": {\"stdlib\": {\"typing\": [\"Any\", \"Optional\"]}}, \"regular\": {\"azurecore\": {\"azure.mgmt.core\": [\"AsyncARMPipelineClient\"], \"azure.profiles\": [\"KnownProfiles\", \"ProfileDefinition\"], \"azure.profiles.multiapiclient\": [\"MultiApiClientMixin\"]}, \"local\": {\"._configuration\": [\"KeyVaultManagementClientConfiguration\"], \"..._serialization\": [\"Deserializer\", \"Serializer\"]}}, \"typing\": {\"azurecore\": {\"azure.core.credentials_async\": [\"AsyncTokenCredential\"]}}}" }, "global_parameters": { "sync": { "credential": { - "signature": "credential, # type: \"TokenCredential\"", - "description": "Credential needed for the client to connect to Azure.", + "signature": "credential: \"TokenCredential\",", + "description": "Credential needed for the client to connect to Azure. Required.", "docstring_type": "~azure.core.credentials.TokenCredential", "required": true }, "subscription_id": { - "signature": "subscription_id, # type: str", - "description": "Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.", + "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 } @@ -31,13 +31,13 @@ "async": { "credential": { "signature": "credential: \"AsyncTokenCredential\",", - "description": "Credential needed for the client to connect to Azure.", + "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.", + "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 } @@ -54,7 +54,7 @@ "required": false }, "base_url": { - "signature": "base_url=\"https://management.azure.com\", # type: str", + "signature": "base_url: str = \"https://management.azure.com\",", "description": "Service URL", "docstring_type": "str", "required": false 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. diff --git a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_vendor.py b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_vendor.py index 138f663c53a4..9aad73fc743e 100644 --- a/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_vendor.py +++ b/sdk/keyvault/azure-mgmt-keyvault/azure/mgmt/keyvault/v2022_07_01/_vendor.py @@ -7,6 +7,7 @@ from azure.core.pipeline.transport import HttpRequest + def _convert_request(request, files=None): data = request.content if not files else None request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) @@ -14,6 +15,7 @@ def _convert_request(request, files=None): request.set_formdata_body(files) return request + def _format_url_section(template, **kwargs): components = template.split("/") while components: @@ -21,7 +23,5 @@ def _format_url_section(template, **kwargs): return template.format(**kwargs) except KeyError as key: formatted_components = template.split("/") - components = [ - c for c in formatted_components if "{}".format(key.args[0]) not in c - ] + components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] template = "/".join(components) 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 index c1257f7f4e11..e5754a47ce68 100644 --- 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 @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "10.1.0" +VERSION = "1.0.0b1" 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 index 1aa2a0b291a3..c2c64fd1638f 100644 --- 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 @@ -14,7 +14,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['KeyVaultManagementClient'] + +__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 index 3f7026a664c5..89ad116ddd98 100644 --- 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 @@ -25,24 +25,19 @@ class KeyVaultManagementClientConfiguration(Configuration): # pylint: disable=t 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. + :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. + 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: + def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: super(KeyVaultManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2022-07-01") # type: str + api_version = kwargs.pop("api_version", "2022-07-01") # type: str if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -52,22 +47,21 @@ def __init__( 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.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-keyvault/{}".format(VERSION)) 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.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + 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.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) + 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) + 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 index eef1838440d3..040d50a95e56 100644 --- 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 @@ -9,20 +9,30 @@ from copy import deepcopy from typing import Any, Awaitable, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.mgmt.core import AsyncARMPipelineClient from .. import models +from ..._serialization import Deserializer, Serializer from ._configuration import KeyVaultManagementClientConfiguration -from .operations import KeysOperations, MHSMPrivateEndpointConnectionsOperations, MHSMPrivateLinkResourcesOperations, ManagedHsmsOperations, Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, SecretsOperations, VaultsOperations +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=too-many-instance-attributes + +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. @@ -48,10 +58,10 @@ class KeyVaultManagementClient: # pylint: disable=too-many-instance-attribute :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. + :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. + 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 @@ -69,47 +79,34 @@ def __init__( base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - self._config = KeyVaultManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) + self._config = KeyVaultManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **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 - ) - self.vaults = VaultsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize) + self.vaults = VaultsOperations(self._client, self._config, self._serialize, self._deserialize) self.private_endpoint_connections = PrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.managed_hsms = ManagedHsmsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.managed_hsms = ManagedHsmsOperations(self._client, self._config, self._serialize, self._deserialize) self.mhsm_private_endpoint_connections = MHSMPrivateEndpointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) self.mhsm_private_link_resources = MHSMPrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - self.secrets = SecretsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) + self.secrets = SecretsOperations(self._client, self._config, self._serialize, self._deserialize) - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -118,7 +115,7 @@ def _send_request( >>> response = await client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + 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 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index 49be258e3efc..9e5cd053e465 100644 --- 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 @@ -19,16 +19,17 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'KeysOperations', - 'VaultsOperations', - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'ManagedHsmsOperations', - 'MHSMPrivateEndpointConnectionsOperations', - 'MHSMPrivateLinkResourcesOperations', - 'Operations', - 'SecretsOperations', + "KeysOperations", + "VaultsOperations", + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "ManagedHsmsOperations", + "MHSMPrivateEndpointConnectionsOperations", + "MHSMPrivateLinkResourcesOperations", + "Operations", + "SecretsOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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/v2022_07_01/aio/operations/_keys_operations.py index dce18a0677ee..0cc44605dca8 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/v2022_07_01/aio/operations/_keys_operations.py @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,10 +28,18 @@ from ... import models as _models from ..._vendor import _convert_request -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 -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class KeysOperations: """ .. warning:: @@ -43,14 +59,15 @@ def __init__(self, *args, **kwargs) -> None: 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") - - @distributed_trace_async + @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 @@ -58,42 +75,126 @@ async def create_if_not_exist( subsequent versions, and does not update existing keys. :param resource_group_name: The name of the resource group which contains the specified key - vault. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. + :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. + :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. + :param parameters: The parameters used to create the specified key. Required. :type parameters: ~azure.mgmt.keyvault.v2022_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 + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Key or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2022_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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or a + IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.KeyCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Key or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - _json = self._serialize.body(parameters, 'KeyCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "KeyCreateParameters") request = build_create_if_not_exist_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.create_if_not_exist.metadata['url'], + content=_content, + template_url=self.create_if_not_exist.metadata["url"], headers=_headers, params=_params, ) @@ -101,67 +202,61 @@ async def create_if_not_exist( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_if_not_exist.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + create_if_not_exist.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> _models.Key: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. + :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. + :param key_name: The name of the key to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -169,65 +264,61 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace - def list( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.KeyListResult]: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. + :param vault_name: The name of the vault which contains the keys to be retrieved. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -235,15 +326,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -260,10 +353,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -273,57 +364,53 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore @distributed_trace_async async def get_version( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - key_version: str, - **kwargs: Any + 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. + 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. + :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. + :param key_version: The version of the key to be retrieved. Required. :type key_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_version_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get_version.metadata['url'], + template_url=self.get_version.metadata["url"], headers=_headers, params=_params, ) @@ -331,69 +418,67 @@ async def get_version( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_version.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore - + get_version.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore @distributed_trace def list_versions( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.KeyListResult]: + 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. + 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. + :param key_name: The name of the key versions to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_versions_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_versions.metadata['url'], + template_url=self.list_versions.metadata["url"], headers=_headers, params=_params, ) @@ -401,16 +486,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_versions_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -427,10 +513,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -440,8 +524,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_versions.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore + list_versions.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore 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/v2022_07_01/aio/operations/_managed_hsms_operations.py index a422eae3f7f5..b97cbb8a4c61 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/v2022_07_01/aio/operations/_managed_hsms_operations.py @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,23 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._managed_hsms_operations import build_check_mhsm_name_availability_request, build_create_or_update_request_initial, build_delete_request_initial, 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_initial, build_update_request_initial -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class ManagedHsmsOperations: """ .. warning:: @@ -45,36 +66,41 @@ def __init__(self, *args, **kwargs) -> None: 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") - async def _create_or_update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -82,49 +108,121 @@ async def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + 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 = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - - deserialized = self._deserialize('ManagedHsm', pipeline_response) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - - @distributed_trace_async + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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] + :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], **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 model type + or a IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -136,20 +234,17 @@ async def begin_create_or_update( :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] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -157,69 +252,71 @@ async def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore async def _update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_update_request_initial( + 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, - template_url=self._update_initial.metadata['url'], + content=_content, + template_url=self._update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -227,49 +324,90 @@ async def _update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + 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 = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - - deserialized = self._deserialize('ManagedHsm', pipeline_response) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - @distributed_trace_async + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to patch the managed HSM Pool. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def begin_update( + self, + resource_group_name: str, + name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -281,20 +419,48 @@ async def begin_update( :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] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def begin_update( + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._update_initial( # type: ignore resource_group_name=resource_group_name, @@ -302,64 +468,59 @@ async def begin_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore async def _delete_initial( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any + self, resource_group_name: str, name: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_delete_request_initial( + request = build_delete_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -367,39 +528,33 @@ async def _delete_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **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) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} if response.status_code == 202: - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, None, response_headers) - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace_async - async def begin_delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param name: The name of the managed HSM Pool to delete. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -411,92 +566,83 @@ async def begin_delete( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore resource_group_name=resource_group_name, name=name, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> Optional[_models.ManagedHsm]: + 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. + :param name: The name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ManagedHsm, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.ManagedHsm]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.ManagedHsm]] - request = build_get_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -504,10 +650,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -517,56 +662,56 @@ async def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -574,15 +719,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -599,10 +746,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -613,48 +758,45 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) + :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.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -662,14 +804,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -686,10 +831,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -700,44 +843,42 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> AsyncIterable[_models.DeletedManagedHsmListResult]: + def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedManagedHsm"]: """The List operation gets information about the deleted managed HSMs associated with the subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedManagedHsmListResult or the result of - cls(response) + :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.DeletedManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -745,13 +886,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -768,10 +913,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -782,48 +925,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore @distributed_trace_async - async def get_deleted( - self, - name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedManagedHsm: + 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. + :param name: The name of the deleted managed HSM. Required. :type name: str - :param location: The location of the deleted managed HSM. + :param location: The location of the deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedManagedHsm, or the result of cls(response) + :return: DeletedManagedHsm or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.DeletedManagedHsm - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsm] - request = build_get_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -831,10 +969,9 @@ async def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -842,40 +979,38 @@ async def get_deleted( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DeletedManagedHsm', pipeline_response) + deserialized = self._deserialize("DeletedManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore async def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any + self, name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -883,38 +1018,31 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + 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')) - + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, None, response_headers) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore @distributed_trace_async - async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param name: The name of the soft-deleted managed HSM. Required. :type name: str - :param location: The location of the soft-deleted managed HSM. + :param location: The location of the soft-deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -926,91 +1054,134 @@ async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._purge_deleted_initial( # type: ignore name=name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore - @distributed_trace_async + @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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckMhsmNameAvailabilityResult, or the result of cls(response) + :return: CheckMhsmNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckMhsmNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def check_mhsm_name_availability( + self, mhsm_name: IO, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CheckMhsmNameAvailabilityResult or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2022_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], **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 model type or a IO type. Required. + :type mhsm_name: ~azure.mgmt.keyvault.v2022_07_01.models.CheckMhsmNameAvailabilityParameters or + IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CheckMhsmNameAvailabilityResult or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckMhsmNameAvailabilityResult + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckMhsmNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckMhsmNameAvailabilityResult] - _json = self._serialize.body(mhsm_name, 'CheckMhsmNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(mhsm_name, (IO, 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, - template_url=self.check_mhsm_name_availability.metadata['url'], + content=_content, + template_url=self.check_mhsm_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1018,22 +1189,20 @@ async def check_mhsm_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckMhsmNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_mhsm_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkMhsmNameAvailability"} # type: ignore - + check_mhsm_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkMhsmNameAvailability"} # type: ignore 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 index 4bb1a36372c8..e51ba893e191 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,17 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._mhsm_private_endpoint_connections_operations import build_delete_request_initial, build_get_request, build_list_by_resource_request, build_put_request -T = TypeVar('T') +from ...operations._mhsm_private_endpoint_connections_operations import ( + build_delete_request, + build_get_request, + build_list_by_resource_request, + build_put_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class MHSMPrivateEndpointConnectionsOperations: """ .. warning:: @@ -45,47 +60,48 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace def list_by_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> AsyncIterable[_models.MHSMPrivateEndpointConnectionsListResult]: + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either MHSMPrivateEndpointConnectionsListResult or the - result of cls(response) + :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.MHSMPrivateEndpointConnectionsListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -93,15 +109,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -118,10 +136,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -132,53 +148,50 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -186,10 +199,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -197,64 +209,142 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - - @distributed_trace_async + @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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - _json = self._serialize.body(properties, 'MHSMPrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -262,10 +352,9 @@ async def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -273,45 +362,44 @@ async def put( 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')) + 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) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore async def _delete_initial( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.MHSMPrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -319,10 +407,9 @@ async def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -332,36 +419,31 @@ async def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if response.status_code == 202: - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace_async async def begin_delete( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -375,55 +457,48 @@ async def begin_delete( result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 index 5dca2b6aad1a..f5d770b048ac 100644 --- 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 @@ -8,7 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -19,9 +26,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._mhsm_private_link_resources_operations import build_list_by_mhsm_resource_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class MHSMPrivateLinkResourcesOperations: """ .. warning:: @@ -41,43 +50,42 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def list_by_mhsm_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateLinkResourceListResult, or the result of cls(response) + :return: MHSMPrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] - request = build_list_by_mhsm_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_mhsm_resource.metadata['url'], + template_url=self.list_by_mhsm_resource.metadata["url"], headers=_headers, params=_params, ) @@ -85,22 +93,20 @@ async def list_by_mhsm_resource( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_mhsm_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # type: ignore - + list_by_mhsm_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # 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 index d07acd303e5d..b3dcb479ebf9 100644 --- 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 @@ -7,9 +7,17 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,9 +28,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._operations import build_list_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class Operations: """ .. warning:: @@ -42,36 +52,36 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> AsyncIterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) + :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.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -79,12 +89,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -101,10 +116,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -114,8 +127,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # type: ignore 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index 2a8480724800..d487b9e20411 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,17 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._private_endpoint_connections_operations import build_delete_request_initial, build_get_request, build_list_by_resource_request, build_put_request -T = TypeVar('T') +from ...operations._private_endpoint_connections_operations import ( + build_delete_request, + build_get_request, + build_list_by_resource_request, + build_put_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateEndpointConnectionsOperations: """ .. warning:: @@ -45,48 +60,45 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def get( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -94,10 +106,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -106,64 +117,139 @@ async def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - @distributed_trace_async + @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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: PrivateEndpointConnection or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - _json = self._serialize.body(properties, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "PrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -171,10 +257,9 @@ async def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -182,45 +267,44 @@ async def put( 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')) + 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore async def _delete_initial( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -228,10 +312,9 @@ async def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -241,37 +324,31 @@ async def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace_async async def begin_delete( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -285,99 +362,93 @@ async def begin_delete( result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def list_by_resource( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.PrivateEndpointConnectionListResult]: + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either PrivateEndpointConnectionListResult or the result - of cls(response) + :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.PrivateEndpointConnectionListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnectionListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -385,15 +456,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -410,10 +483,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -423,8 +494,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore 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 index a4fbf4cc18f1..74103391a603 100644 --- 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 @@ -8,7 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -19,9 +26,11 @@ from ... import models as _models from ..._vendor import _convert_request from ...operations._private_link_resources_operations import build_list_by_vault_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateLinkResourcesOperations: """ .. warning:: @@ -41,43 +50,41 @@ def __init__(self, *args, **kwargs) -> None: 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") - @distributed_trace_async async def list_by_vault( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateLinkResourceListResult, or the result of cls(response) + :return: PrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] - request = build_list_by_vault_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_vault.metadata['url'], + template_url=self.list_by_vault.metadata["url"], headers=_headers, params=_params, ) @@ -85,22 +92,20 @@ async def list_by_vault( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_vault.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore - + list_by_vault.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # 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 index d7080d77aa9c..532558262099 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,10 +28,17 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._secrets_operations import build_create_or_update_request, build_get_request, build_list_request, build_update_request -T = TypeVar('T') +from ...operations._secrets_operations import ( + build_create_or_update_request, + build_get_request, + build_list_request, + build_update_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class SecretsOperations: """ .. warning:: @@ -43,14 +58,15 @@ def __init__(self, *args, **kwargs) -> None: 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") - - @distributed_trace_async + @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 @@ -58,31 +74,115 @@ async def create_or_update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.SecretCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -92,7 +192,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -100,10 +201,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -111,26 +211,27 @@ async def create_or_update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - @distributed_trace_async + @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 @@ -138,31 +239,109 @@ async def update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :param secret_name: Name of the secret. Required. :type secret_name: str - :param parameters: Parameters to patch the secret. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.SecretPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -172,7 +351,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -180,10 +360,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -191,60 +370,56 @@ async def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - **kwargs: Any - ) -> _models.Secret: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param secret_name: The name of the secret. + :param secret_name: The name of the secret. Required. :type secret_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -252,70 +427,68 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace def list( - self, - resource_group_name: str, - vault_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.SecretListResult]: + 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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SecretListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.SecretListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SecretListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SecretListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, top=top, - template_url=self.list.metadata['url'], + api_version=api_version, + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -323,16 +496,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -349,10 +523,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -362,8 +534,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore 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 index 0beb9b7aee05..cf7bfbf24f86 100644 --- 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 @@ -6,10 +6,18 @@ # 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, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,10 +30,25 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._vaults_operations import build_check_name_availability_request, build_create_or_update_request_initial, 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_initial, build_update_access_policy_request, build_update_request -T = TypeVar('T') +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, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class VaultsOperations: """ .. warning:: @@ -45,36 +68,45 @@ def __init__(self, *args, **kwargs) -> None: 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") - async def _create_or_update_initial( self, resource_group_name: str, vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **kwargs: Any ) -> _models.Vault: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -82,10 +114,9 @@ async def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -93,35 +124,109 @@ async def _create_or_update_initial( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - - @distributed_trace_async + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], + **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -132,20 +237,17 @@ async def begin_create_or_update( Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -153,74 +255,140 @@ async def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace_async + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -229,7 +397,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -237,10 +406,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -248,55 +416,54 @@ async def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -304,10 +471,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -317,45 +483,42 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace_async - async def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -363,63 +526,140 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - - @distributed_trace_async + @overload async def update_access_policy( self, resource_group_name: str, vault_name: str, - operation_kind: Union[str, "_models.AccessPolicyUpdateKind"], + 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: VaultAccessPolicyParameters or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -429,7 +669,8 @@ async def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -437,10 +678,9 @@ async def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -448,58 +688,58 @@ async def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -507,15 +747,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -532,10 +774,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -545,46 +785,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -592,14 +829,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -616,10 +856,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -629,43 +867,41 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> AsyncIterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> AsyncIterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) + :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.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -673,13 +909,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -696,10 +936,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -709,48 +947,43 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace_async - async def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -758,50 +991,47 @@ async def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore async def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -809,10 +1039,9 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -822,21 +1051,15 @@ async def _purge_deleted_initial( # pylint: disable=inconsistent-return-stateme if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace_async - async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -848,62 +1071,51 @@ async def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace - def list( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable[_models.ResourceListResult]: + 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. @@ -916,31 +1128,37 @@ def list( that overriding this default value may result in unsupported behavior. :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) + :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.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + filter = kwargs.pop( + "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") + ) # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -948,15 +1166,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -973,10 +1193,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -986,47 +1204,95 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace_async + @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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def check_name_availability( + self, vault_name: IO, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], **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 model type or a IO type. Required. + :type vault_name: ~azure.mgmt.keyvault.v2022_07_01.models.VaultCheckNameAvailabilityParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CheckNameAvailabilityResult or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckNameAvailabilityResult + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1034,22 +1300,20 @@ async def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # 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 index e9fe5fb6248c..852798d93869 100644 --- 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 @@ -86,144 +86,142 @@ from ._models_py3 import VaultProperties from ._models_py3 import VirtualNetworkRule - -from ._key_vault_management_client_enums import ( - 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, -) +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 * # type: ignore # 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', + "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() \ No newline at end of file +_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 index 63b601387398..bc1cf80cd81d 100644 --- 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 @@ -11,20 +11,21 @@ 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. - """ + """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 - """ + """Activation Status.""" #: The managed HSM Pool is active. ACTIVE = "Active" @@ -35,14 +36,16 @@ class ActivationStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): #: Failed to activate managed hsm. FAILED = "Failed" + class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """CertificatePermissions.""" ALL = "all" GET = "get" LIST = "list" DELETE = "delete" CREATE = "create" - IMPORT_ENUM = "import" + IMPORT = "import" UPDATE = "update" MANAGECONTACTS = "managecontacts" GETISSUERS = "getissuers" @@ -55,13 +58,14 @@ class CertificatePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): BACKUP = "backup" RESTORE = "restore" + class CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The vault's create mode to indicate whether the vault need to be recovered or not. - """ + """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 @@ -73,24 +77,25 @@ class DeletionRecoveryLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta): RECOVERABLE = "Recoverable" RECOVERABLE_PROTECTED_SUBSCRIPTION = "Recoverable+ProtectedSubscription" + class IdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of identity. - """ + """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. - """ + """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. @@ -102,19 +107,21 @@ class JsonWebKeyOperation(str, Enum, metaclass=CaseInsensitiveEnumMeta): VERIFY = "verify" WRAP_KEY = "wrapKey" UNWRAP_KEY = "unwrapKey" - IMPORT_ENUM = "import" + IMPORT = "import" RELEASE = "release" + class JsonWebKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of the key. For valid values, see JsonWebKeyType. - """ + """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" @@ -127,7 +134,7 @@ class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): LIST = "list" CREATE = "create" UPDATE = "update" - IMPORT_ENUM = "import" + IMPORT = "import" DELETE = "delete" BACKUP = "backup" RESTORE = "restore" @@ -138,26 +145,27 @@ class KeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): GETROTATIONPOLICY = "getrotationpolicy" SETROTATIONPOLICY = "setrotationpolicy" + class KeyRotationPolicyActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of action. - """ + """The type of action.""" ROTATE = "rotate" NOTIFY = "notify" + class ManagedHsmSkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU Family of the managed HSM Pool - """ + """SKU Family of the managed HSM Pool.""" B = "B" + class ManagedHsmSkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU of the managed HSM Pool - """ + """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. @@ -166,6 +174,7 @@ class NetworkRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta): 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'. @@ -174,9 +183,9 @@ class NetworkRuleBypassOptions(str, Enum, metaclass=CaseInsensitiveEnumMeta): AZURE_SERVICES = "AzureServices" NONE = "None" + class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The current provisioning state. - """ + """The current provisioning state.""" SUCCEEDED = "Succeeded" CREATING = "Creating" @@ -185,18 +194,18 @@ class PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsens FAILED = "Failed" DISCONNECTED = "Disconnected" + class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The private endpoint connection status. - """ + """The private endpoint connection status.""" PENDING = "Pending" APPROVED = "Approved" REJECTED = "Rejected" DISCONNECTED = "Disconnected" + class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state. - """ + """Provisioning state.""" #: The managed HSM Pool has been full provisioned. SUCCEEDED = "Succeeded" @@ -215,6 +224,7 @@ class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): #: The managed HSM pool is being restored from full HSM backup. RESTORING = "Restoring" + class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Control permission for data plane traffic coming from public networks while private endpoint is enabled. @@ -223,6 +233,7 @@ class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta): 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. @@ -231,7 +242,9 @@ class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta): ACCOUNT_NAME_INVALID = "AccountNameInvalid" ALREADY_EXISTS = "AlreadyExists" + class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """SecretPermissions.""" ALL = "all" GET = "get" @@ -243,20 +256,22 @@ class SecretPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): RECOVER = "recover" PURGE = "purge" + class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """SKU family name - """ + """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. - """ + """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" @@ -274,9 +289,9 @@ class StoragePermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): GETSAS = "getsas" DELETESAS = "deletesas" + class VaultProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Provisioning state of the vault. - """ + """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 index f0fabe3cd085..7075dfa2cc70 100644 --- 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 @@ -1,4 +1,5 @@ # 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. @@ -9,43 +10,42 @@ import datetime from typing import Dict, List, Optional, TYPE_CHECKING, Union -from azure.core.exceptions import HttpResponseError -import msrest.serialization +from ... import _serialization if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - import __init__ as _models + from .. import models as _models -class AccessPolicyEntry(msrest.serialization.Model): +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 Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and certificates. + :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}, + "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'}, + "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__( @@ -58,52 +58,47 @@ def __init__( **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. 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. + :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: Required. Permissions the identity has for keys, secrets and - certificates. + :keyword permissions: Permissions the identity has for keys, secrets and certificates. + Required. :paramtype permissions: ~azure.mgmt.keyvault.v2022_07_01.models.Permissions """ - super(AccessPolicyEntry, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.object_id = object_id self.application_id = application_id self.permissions = permissions -class Action(msrest.serialization.Model): +class Action(_serialization.Model): """Action. - :ivar type: The type of action. Known values are: "rotate", "notify". + :ivar type: The type of action. 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'}, + "type": {"key": "type", "type": "str"}, } - def __init__( - self, - *, - type: Optional[Union[str, "_models.KeyRotationPolicyActionType"]] = None, - **kwargs - ): + def __init__(self, *, type: Optional[Union[str, "_models.KeyRotationPolicyActionType"]] = None, **kwargs): """ - :keyword type: The type of action. Known values are: "rotate", "notify". + :keyword type: The type of action. Known values are: "rotate" and "notify". :paramtype type: str or ~azure.mgmt.keyvault.v2022_07_01.models.KeyRotationPolicyActionType """ - super(Action, self).__init__(**kwargs) + super().__init__(**kwargs) self.type = type -class Attributes(msrest.serialization.Model): +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. @@ -121,16 +116,16 @@ class Attributes(msrest.serialization.Model): """ _validation = { - 'created': {'readonly': True}, - 'updated': {'readonly': True}, + "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'}, + "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__( @@ -149,7 +144,7 @@ def __init__( :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. :paramtype expires: ~datetime.datetime """ - super(Attributes, self).__init__(**kwargs) + super().__init__(**kwargs) self.enabled = enabled self.not_before = not_before self.expires = expires @@ -157,38 +152,33 @@ def __init__( self.updated = None -class CheckMhsmNameAvailabilityParameters(msrest.serialization.Model): +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 Azure. - :ivar name: Required. The managed hsm name. + :ivar name: The managed hsm name. Required. :vartype name: str """ _validation = { - 'name': {'required': True}, + "name": {"required": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, } - def __init__( - self, - *, - name: str, - **kwargs - ): + def __init__(self, *, name: str, **kwargs): """ - :keyword name: Required. The managed hsm name. + :keyword name: The managed hsm name. Required. :paramtype name: str """ - super(CheckMhsmNameAvailabilityParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name -class CheckMhsmNameAvailabilityResult(msrest.serialization.Model): +class CheckMhsmNameAvailabilityResult(_serialization.Model): """The CheckMhsmNameAvailability operation response. Variables are only populated by the server, and will be ignored when sending a request. @@ -198,37 +188,33 @@ class CheckMhsmNameAvailabilityResult(msrest.serialization.Model): 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", "AlreadyExists". + 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}, + "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'}, + "name_available": {"key": "nameAvailable", "type": "bool"}, + "reason": {"key": "reason", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(CheckMhsmNameAvailabilityResult, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.name_available = None self.reason = None self.message = None -class CheckNameAvailabilityResult(msrest.serialization.Model): +class CheckNameAvailabilityResult(_serialization.Model): """The CheckNameAvailability operation response. Variables are only populated by the server, and will be ignored when sending a request. @@ -238,37 +224,33 @@ class CheckNameAvailabilityResult(msrest.serialization.Model): 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", "AlreadyExists". + 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}, + "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'}, + "name_available": {"key": "nameAvailable", "type": "bool"}, + "reason": {"key": "reason", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(CheckNameAvailabilityResult, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.name_available = None self.reason = None self.message = None -class CloudErrorBody(msrest.serialization.Model): +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. @@ -279,17 +261,11 @@ class CloudErrorBody(msrest.serialization.Model): """ _attribute_map = { - 'code': {'key': 'code', 'type': 'str'}, - 'message': {'key': 'message', 'type': 'str'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - *, - code: Optional[str] = None, - message: Optional[str] = None, - **kwargs - ): + def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs): """ :keyword code: Error code. This is a mnemonic that can be consumed programmatically. :paramtype code: str @@ -297,12 +273,12 @@ def __init__( with service version. :paramtype message: str """ - super(CloudErrorBody, self).__init__(**kwargs) + super().__init__(**kwargs) self.code = code self.message = message -class DeletedManagedHsm(msrest.serialization.Model): +class DeletedManagedHsm(_serialization.Model): """DeletedManagedHsm. Variables are only populated by the server, and will be ignored when sending a request. @@ -318,36 +294,31 @@ class DeletedManagedHsm(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "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'}, + "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 - ): + def __init__(self, *, properties: Optional["_models.DeletedManagedHsmProperties"] = None, **kwargs): """ :keyword properties: Properties of the deleted managed HSM. :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.DeletedManagedHsmProperties """ - super(DeletedManagedHsm, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None self.properties = properties -class DeletedManagedHsmListResult(msrest.serialization.Model): +class DeletedManagedHsmListResult(_serialization.Model): """List of deleted managed HSM Pools. :ivar value: The list of deleted managed HSM Pools. @@ -357,16 +328,12 @@ class DeletedManagedHsmListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DeletedManagedHsm]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.DeletedManagedHsm"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of deleted managed HSM Pools. @@ -374,12 +341,12 @@ def __init__( :keyword next_link: The URL to get the next set of deleted managed HSM Pools. :paramtype next_link: str """ - super(DeletedManagedHsmListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class DeletedManagedHsmProperties(msrest.serialization.Model): +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. @@ -394,35 +361,31 @@ class DeletedManagedHsmProperties(msrest.serialization.Model): :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: A set of tags. Tags of the original managed HSM. + :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}, + "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}'}, + "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 - ): - """ - """ - super(DeletedManagedHsmProperties, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.mhsm_id = None self.location = None self.deletion_date = None @@ -431,7 +394,7 @@ def __init__( self.tags = None -class DeletedVault(msrest.serialization.Model): +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. @@ -447,36 +410,31 @@ class DeletedVault(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "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'}, + "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 - ): + def __init__(self, *, properties: Optional["_models.DeletedVaultProperties"] = None, **kwargs): """ :keyword properties: Properties of the vault. :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.DeletedVaultProperties """ - super(DeletedVault, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None self.properties = properties -class DeletedVaultListResult(msrest.serialization.Model): +class DeletedVaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of deleted vaults. @@ -486,16 +444,12 @@ class DeletedVaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DeletedVault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.DeletedVault"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of deleted vaults. @@ -503,12 +457,12 @@ def __init__( :keyword next_link: The URL to get the next set of deleted vaults. :paramtype next_link: str """ - super(DeletedVaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class DeletedVaultProperties(msrest.serialization.Model): +class DeletedVaultProperties(_serialization.Model): """Properties of the deleted vault. Variables are only populated by the server, and will be ignored when sending a request. @@ -521,37 +475,33 @@ class DeletedVaultProperties(msrest.serialization.Model): :vartype deletion_date: ~datetime.datetime :ivar scheduled_purge_date: The scheduled purged date. :vartype scheduled_purge_date: ~datetime.datetime - :ivar tags: A set of tags. Tags of the original vault. + :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}, + "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'}, + "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 - ): - """ - """ - super(DeletedVaultProperties, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.vault_id = None self.location = None self.deletion_date = None @@ -560,7 +510,7 @@ def __init__( self.purge_protection_enabled = None -class DimensionProperties(msrest.serialization.Model): +class DimensionProperties(_serialization.Model): """Type of operation: get, read, delete, etc. :ivar name: Name of dimension. @@ -573,9 +523,9 @@ class DimensionProperties(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'to_be_exported_for_shoebox': {'key': 'toBeExportedForShoebox', 'type': 'bool'}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "to_be_exported_for_shoebox": {"key": "toBeExportedForShoebox", "type": "bool"}, } def __init__( @@ -595,13 +545,13 @@ def __init__( exported for Shoebox. :paramtype to_be_exported_for_shoebox: bool """ - super(DimensionProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.to_be_exported_for_shoebox = to_be_exported_for_shoebox -class Error(msrest.serialization.Model): +class Error(_serialization.Model): """The server error. Variables are only populated by the server, and will be ignored when sending a request. @@ -615,63 +565,54 @@ class Error(msrest.serialization.Model): """ _validation = { - 'code': {'readonly': True}, - 'message': {'readonly': True}, - 'inner_error': {'readonly': True}, + "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'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, + "inner_error": {"key": "innererror", "type": "Error"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(Error, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.code = None self.message = None self.inner_error = None -class IPRule(msrest.serialization.Model): +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 Azure. - :ivar value: Required. 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). + :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}, + "value": {"required": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, + "value": {"key": "value", "type": "str"}, } - def __init__( - self, - *, - value: str, - **kwargs - ): + def __init__(self, *, value: str, **kwargs): """ - :keyword value: Required. 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). + :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(IPRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class Resource(msrest.serialization.Model): +class Resource(_serialization.Model): """Key Vault resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -684,33 +625,29 @@ class Resource(msrest.serialization.Model): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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}, + "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}'}, + "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 - ): - """ - """ - super(Resource, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -718,7 +655,7 @@ def __init__( self.tags = None -class Key(Resource): +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. @@ -731,19 +668,19 @@ class Key(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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", "RSA-HSM". + "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", "P-256K". + 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 @@ -758,30 +695,30 @@ class Key(Resource): """ _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'}, + "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__( @@ -800,14 +737,14 @@ def __init__( :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", "RSA-HSM". + "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", "P-256K". + 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. @@ -816,7 +753,7 @@ def __init__( input. Omitted if empty. :paramtype release_policy: ~azure.mgmt.keyvault.v2022_07_01.models.KeyReleasePolicy """ - super(Key, self).__init__(**kwargs) + super().__init__(**kwargs) self.attributes = attributes self.kty = kty self.key_ops = key_ops @@ -828,7 +765,7 @@ def __init__( self.release_policy = release_policy -class KeyAttributes(msrest.serialization.Model): +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. @@ -836,17 +773,17 @@ class KeyAttributes(msrest.serialization.Model): :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: long + :vartype not_before: int :ivar expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :vartype expires: long + :vartype expires: int :ivar created: Creation time in seconds since 1970-01-01T00:00:00Z. - :vartype created: long + :vartype created: int :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: long + :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", + 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. @@ -854,19 +791,19 @@ class KeyAttributes(msrest.serialization.Model): """ _validation = { - 'created': {'readonly': True}, - 'updated': {'readonly': True}, - 'recovery_level': {'readonly': True}, + "created": {"readonly": True}, + "updated": {"readonly": True}, + "recovery_level": {"readonly": True}, } _attribute_map = { - 'enabled': {'key': 'enabled', 'type': 'bool'}, - 'not_before': {'key': 'nbf', 'type': 'long'}, - 'expires': {'key': 'exp', 'type': 'long'}, - 'created': {'key': 'created', 'type': 'long'}, - 'updated': {'key': 'updated', 'type': 'long'}, - 'recovery_level': {'key': 'recoveryLevel', 'type': 'str'}, - 'exportable': {'key': 'exportable', 'type': 'bool'}, + "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__( @@ -882,13 +819,13 @@ def __init__( :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: long + :paramtype not_before: int :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. - :paramtype expires: long + :paramtype expires: int :keyword exportable: Indicates if the private key can be exported. :paramtype exportable: bool """ - super(KeyAttributes, self).__init__(**kwargs) + super().__init__(**kwargs) self.enabled = enabled self.not_before = not_before self.expires = expires @@ -898,45 +835,39 @@ def __init__( self.exportable = exportable -class KeyCreateParameters(msrest.serialization.Model): +class KeyCreateParameters(_serialization.Model): """The parameters used to create a key. All required parameters must be populated in order to send to Azure. - :ivar tags: A set of tags. The tags that will be assigned to the key. + :ivar tags: The tags that will be assigned to the key. :vartype tags: dict[str, str] - :ivar properties: Required. The properties of the key to be created. + :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}, + "properties": {"required": True}, } _attribute_map = { - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'KeyProperties'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "KeyProperties"}, } - def __init__( - self, - *, - properties: "_models.KeyProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs - ): + def __init__(self, *, properties: "_models.KeyProperties", tags: Optional[Dict[str, str]] = None, **kwargs): """ - :keyword tags: A set of tags. The tags that will be assigned to the key. + :keyword tags: The tags that will be assigned to the key. :paramtype tags: dict[str, str] - :keyword properties: Required. The properties of the key to be created. + :keyword properties: The properties of the key to be created. Required. :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.KeyProperties """ - super(KeyCreateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class KeyListResult(msrest.serialization.Model): +class KeyListResult(_serialization.Model): """The page of keys. :ivar value: The key resources. @@ -946,29 +877,23 @@ class KeyListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Key]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Key"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(KeyListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class KeyProperties(msrest.serialization.Model): +class KeyProperties(_serialization.Model): """The properties of the key. Variables are only populated by the server, and will be ignored when sending a request. @@ -976,14 +901,14 @@ class KeyProperties(msrest.serialization.Model): :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", "RSA-HSM". + "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", "P-256K". + 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 @@ -998,20 +923,20 @@ class KeyProperties(msrest.serialization.Model): """ _validation = { - 'key_uri': {'readonly': True}, - 'key_uri_with_version': {'readonly': True}, + "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'}, + "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__( @@ -1030,14 +955,14 @@ def __init__( :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", "RSA-HSM". + "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", "P-256K". + 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. @@ -1046,7 +971,7 @@ def __init__( input. Omitted if empty. :paramtype release_policy: ~azure.mgmt.keyvault.v2022_07_01.models.KeyReleasePolicy """ - super(KeyProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.attributes = attributes self.kty = kty self.key_ops = key_ops @@ -1058,7 +983,7 @@ def __init__( self.release_policy = release_policy -class KeyReleasePolicy(msrest.serialization.Model): +class KeyReleasePolicy(_serialization.Model): """KeyReleasePolicy. :ivar content_type: Content type and version of key release policy. @@ -1068,16 +993,12 @@ class KeyReleasePolicy(msrest.serialization.Model): """ _attribute_map = { - 'content_type': {'key': 'contentType', 'type': 'str'}, - 'data': {'key': 'data', 'type': 'base64'}, + "content_type": {"key": "contentType", "type": "str"}, + "data": {"key": "data", "type": "base64"}, } def __init__( - self, - *, - content_type: Optional[str] = "application/json; charset=utf-8", - data: Optional[bytes] = None, - **kwargs + self, *, content_type: str = "application/json; charset=utf-8", data: Optional[bytes] = None, **kwargs ): """ :keyword content_type: Content type and version of key release policy. @@ -1085,54 +1006,49 @@ def __init__( :keyword data: Blob encoding the policy rules under which the key can be released. :paramtype data: bytes """ - super(KeyReleasePolicy, self).__init__(**kwargs) + super().__init__(**kwargs) self.content_type = content_type self.data = data -class KeyRotationPolicyAttributes(msrest.serialization.Model): +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: long + :vartype created: int :ivar updated: Last updated time in seconds since 1970-01-01T00:00:00Z. - :vartype updated: long + :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}, + "created": {"readonly": True}, + "updated": {"readonly": True}, } _attribute_map = { - 'created': {'key': 'created', 'type': 'long'}, - 'updated': {'key': 'updated', 'type': 'long'}, - 'expiry_time': {'key': 'expiryTime', 'type': 'str'}, + "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 - ): + def __init__(self, *, expiry_time: Optional[str] = None, **kwargs): """ :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(KeyRotationPolicyAttributes, self).__init__(**kwargs) + super().__init__(**kwargs) self.created = None self.updated = None self.expiry_time = expiry_time -class LifetimeAction(msrest.serialization.Model): +class LifetimeAction(_serialization.Model): """LifetimeAction. :ivar trigger: The trigger of key rotation policy lifetimeAction. @@ -1142,16 +1058,12 @@ class LifetimeAction(msrest.serialization.Model): """ _attribute_map = { - 'trigger': {'key': 'trigger', 'type': 'Trigger'}, - 'action': {'key': 'action', 'type': 'Action'}, + "trigger": {"key": "trigger", "type": "Trigger"}, + "action": {"key": "action", "type": "Action"}, } def __init__( - self, - *, - trigger: Optional["_models.Trigger"] = None, - action: Optional["_models.Action"] = None, - **kwargs + self, *, trigger: Optional["_models.Trigger"] = None, action: Optional["_models.Action"] = None, **kwargs ): """ :keyword trigger: The trigger of key rotation policy lifetimeAction. @@ -1159,12 +1071,12 @@ def __init__( :keyword action: The action of key rotation policy lifetimeAction. :paramtype action: ~azure.mgmt.keyvault.v2022_07_01.models.Action """ - super(LifetimeAction, self).__init__(**kwargs) + super().__init__(**kwargs) self.trigger = trigger self.action = action -class LogSpecification(msrest.serialization.Model): +class LogSpecification(_serialization.Model): """Log specification of operation. :ivar name: Name of log specification. @@ -1176,9 +1088,9 @@ class LogSpecification(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'blob_duration': {'key': 'blobDuration', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "blob_duration": {"key": "blobDuration", "type": "str"}, } def __init__( @@ -1197,13 +1109,13 @@ def __init__( :keyword blob_duration: Blob duration of specification. :paramtype blob_duration: str """ - super(LogSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.blob_duration = blob_duration -class ManagedHsmResource(msrest.serialization.Model): +class ManagedHsmResource(_serialization.Model): """Managed HSM resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -1218,7 +1130,7 @@ class ManagedHsmResource(msrest.serialization.Model): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -1226,20 +1138,20 @@ class ManagedHsmResource(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'system_data': {'readonly': True}, + "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'}, + "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__( @@ -1255,10 +1167,10 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :keyword tags: Resource tags. :paramtype tags: dict[str, str] """ - super(ManagedHsmResource, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -1283,7 +1195,7 @@ class ManagedHsm(ManagedHsmResource): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -1293,21 +1205,21 @@ class ManagedHsm(ManagedHsmResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'system_data': {'readonly': True}, + "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'}, + "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__( @@ -1324,16 +1236,16 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :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(ManagedHsm, self).__init__(location=location, sku=sku, tags=tags, **kwargs) + super().__init__(location=location, sku=sku, tags=tags, **kwargs) self.properties = properties -class ManagedHsmError(msrest.serialization.Model): +class ManagedHsmError(_serialization.Model): """The error exception. Variables are only populated by the server, and will be ignored when sending a request. @@ -1343,24 +1255,20 @@ class ManagedHsmError(msrest.serialization.Model): """ _validation = { - 'error': {'readonly': True}, + "error": {"readonly": True}, } _attribute_map = { - 'error': {'key': 'error', 'type': 'Error'}, + "error": {"key": "error", "type": "Error"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(ManagedHsmError, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.error = None -class ManagedHsmListResult(msrest.serialization.Model): +class ManagedHsmListResult(_serialization.Model): """List of managed HSM Pools. :ivar value: The list of managed HSM Pools. @@ -1370,16 +1278,12 @@ class ManagedHsmListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[ManagedHsm]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 + self, *, value: Optional[List["_models.ManagedHsm"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of managed HSM Pools. @@ -1387,12 +1291,12 @@ def __init__( :keyword next_link: The URL to get the next set of managed HSM Pools. :paramtype next_link: str """ - super(ManagedHsmListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class ManagedHsmProperties(msrest.serialization.Model): +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. @@ -1419,12 +1323,12 @@ class ManagedHsmProperties(msrest.serialization.Model): 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", "default". + 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", "Restoring". + "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. @@ -1434,7 +1338,7 @@ class ManagedHsmProperties(msrest.serialization.Model): :vartype private_endpoint_connections: list[~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnectionItem] :ivar public_network_access: Control permission for data plane traffic coming from public - networks while private endpoint is enabled. Known values are: "Enabled", "Disabled". + networks while private endpoint is enabled. 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. @@ -1442,27 +1346,30 @@ class ManagedHsmProperties(msrest.serialization.Model): """ _validation = { - 'hsm_uri': {'readonly': True}, - 'status_message': {'readonly': True}, - 'provisioning_state': {'readonly': True}, - 'private_endpoint_connections': {'readonly': True}, - 'scheduled_purge_date': {'readonly': True}, + "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'}, + "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__( @@ -1470,9 +1377,9 @@ def __init__( *, tenant_id: Optional[str] = None, initial_admin_object_ids: Optional[List[str]] = None, - enable_soft_delete: Optional[bool] = True, - soft_delete_retention_in_days: Optional[int] = 90, - enable_purge_protection: Optional[bool] = True, + 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: Optional[Union[str, "_models.PublicNetworkAccess"]] = None, @@ -1500,17 +1407,17 @@ def __init__( 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", "default". + 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 for data plane traffic coming from public - networks while private endpoint is enabled. Known values are: "Enabled", "Disabled". + networks while private endpoint is enabled. Known values are: "Enabled" and "Disabled". :paramtype public_network_access: str or ~azure.mgmt.keyvault.v2022_07_01.models.PublicNetworkAccess """ - super(ManagedHsmProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.initial_admin_object_ids = initial_admin_object_ids self.hsm_uri = None @@ -1526,81 +1433,77 @@ def __init__( self.scheduled_purge_date = None -class ManagedHSMSecurityDomainProperties(msrest.serialization.Model): +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", "Failed". + "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}, + "activation_status": {"readonly": True}, + "activation_status_message": {"readonly": True}, } _attribute_map = { - 'activation_status': {'key': 'activationStatus', 'type': 'str'}, - 'activation_status_message': {'key': 'activationStatusMessage', 'type': 'str'}, + "activation_status": {"key": "activationStatus", "type": "str"}, + "activation_status_message": {"key": "activationStatusMessage", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(ManagedHSMSecurityDomainProperties, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.activation_status = None self.activation_status_message = None -class ManagedHsmSku(msrest.serialization.Model): +class ManagedHsmSku(_serialization.Model): """SKU details. All required parameters must be populated in order to send to Azure. - :ivar family: Required. SKU Family of the managed HSM Pool. Known values are: "B". + :ivar family: SKU Family of the managed HSM Pool. Required. "B" :vartype family: str or ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSkuFamily - :ivar name: Required. SKU of the managed HSM Pool. Known values are: "Standard_B1", + :ivar name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1" and "Custom_B32". :vartype name: str or ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSkuName """ _validation = { - 'family': {'required': True}, - 'name': {'required': True}, + "family": {"required": True}, + "name": {"required": True}, } _attribute_map = { - 'family': {'key': 'family', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, + "family": {"key": "family", "type": "str"}, + "name": {"key": "name", "type": "str"}, } def __init__( self, *, - family: Union[str, "_models.ManagedHsmSkuFamily"] = "B", + family: Union[str, "_models.ManagedHsmSkuFamily"], name: Union[str, "_models.ManagedHsmSkuName"], **kwargs ): """ - :keyword family: Required. SKU Family of the managed HSM Pool. Known values are: "B". + :keyword family: SKU Family of the managed HSM Pool. Required. "B" :paramtype family: str or ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSkuFamily - :keyword name: Required. SKU of the managed HSM Pool. Known values are: "Standard_B1", + :keyword name: SKU of the managed HSM Pool. Required. Known values are: "Standard_B1" and "Custom_B32". :paramtype name: str or ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSkuName """ - super(ManagedHsmSku, self).__init__(**kwargs) + super().__init__(**kwargs) self.family = family self.name = name -class MetricSpecification(msrest.serialization.Model): +class MetricSpecification(_serialization.Model): # pylint: disable=too-many-instance-attributes """Metric specification of operation. :ivar name: Name of metric specification. @@ -1629,17 +1532,17 @@ class MetricSpecification(msrest.serialization.Model): """ _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'}, + "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__( @@ -1683,7 +1586,7 @@ def __init__( :keyword internal_metric_name: The internal metric name. :paramtype internal_metric_name: str """ - super(MetricSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display_name = display_name self.display_description = display_description @@ -1697,49 +1600,44 @@ def __init__( self.internal_metric_name = internal_metric_name -class MHSMIPRule(msrest.serialization.Model): +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 Azure. - :ivar value: Required. 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). + :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}, + "value": {"required": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, + "value": {"key": "value", "type": "str"}, } - def __init__( - self, - *, - value: str, - **kwargs - ): + def __init__(self, *, value: str, **kwargs): """ - :keyword value: Required. 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). + :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(MHSMIPRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class MHSMNetworkRuleSet(msrest.serialization.Model): +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", + '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", "Deny". + "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] @@ -1749,10 +1647,10 @@ class MHSMNetworkRuleSet(msrest.serialization.Model): """ _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]'}, + "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__( @@ -1766,12 +1664,12 @@ 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", + '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", "Deny". + 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] @@ -1779,14 +1677,14 @@ def __init__( :paramtype virtual_network_rules: list[~azure.mgmt.keyvault.v2022_07_01.models.MHSMVirtualNetworkRule] """ - super(MHSMNetworkRuleSet, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class MHSMPrivateEndpoint(_serialization.Model): """Private endpoint object properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -1796,24 +1694,20 @@ class MHSMPrivateEndpoint(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, + "id": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(MHSMPrivateEndpoint, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None -class MHSMPrivateEndpointConnection(ManagedHsmResource): +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. @@ -1828,7 +1722,7 @@ class MHSMPrivateEndpointConnection(ManagedHsmResource): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -1841,30 +1735,33 @@ class MHSMPrivateEndpointConnection(ManagedHsmResource): :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", "Disconnected". + 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}, + "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'}, + "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__( @@ -1884,7 +1781,7 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :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 @@ -1894,18 +1791,18 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnectionProvisioningState """ - super(MHSMPrivateEndpointConnection, self).__init__(location=location, sku=sku, tags=tags, **kwargs) + 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(msrest.serialization.Model): +class MHSMPrivateEndpointConnectionItem(_serialization.Model): """Private endpoint connection item. :ivar id: Id of private endpoint connection. @@ -1918,23 +1815,26 @@ class MHSMPrivateEndpointConnectionItem(msrest.serialization.Model): :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", "Disconnected". + 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'}, + "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, + 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, @@ -1952,11 +1852,11 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnectionProvisioningState """ - super(MHSMPrivateEndpointConnectionItem, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id self.etag = etag self.private_endpoint = private_endpoint @@ -1964,7 +1864,7 @@ def __init__( self.provisioning_state = provisioning_state -class MHSMPrivateEndpointConnectionsListResult(msrest.serialization.Model): +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. @@ -1974,8 +1874,8 @@ class MHSMPrivateEndpointConnectionsListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[MHSMPrivateEndpointConnection]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[MHSMPrivateEndpointConnection]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( @@ -1991,7 +1891,7 @@ def __init__( :keyword next_link: The URL to get the next set of managed HSM Pools. :paramtype next_link: str """ - super(MHSMPrivateEndpointConnectionsListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link @@ -2011,7 +1911,7 @@ class MHSMPrivateLinkResource(ManagedHsmResource): :vartype location: str :ivar sku: SKU details. :vartype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar system_data: Metadata pertaining to creation and last modification of the key vault resource. @@ -2025,25 +1925,25 @@ class MHSMPrivateLinkResource(ManagedHsmResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'system_data': {'readonly': True}, - 'group_id': {'readonly': True}, - 'required_members': {'readonly': True}, + "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]'}, + "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__( @@ -2060,18 +1960,18 @@ def __init__( :paramtype location: str :keyword sku: SKU details. :paramtype sku: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmSku - :keyword tags: A set of tags. Resource tags. + :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(MHSMPrivateLinkResource, self).__init__(location=location, sku=sku, tags=tags, **kwargs) + 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(msrest.serialization.Model): +class MHSMPrivateLinkResourceListResult(_serialization.Model): """A list of private link resources. :ivar value: Array of private link resources. @@ -2079,41 +1979,36 @@ class MHSMPrivateLinkResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[MHSMPrivateLinkResource]'}, + "value": {"key": "value", "type": "[MHSMPrivateLinkResource]"}, } - def __init__( - self, - *, - value: Optional[List["_models.MHSMPrivateLinkResource"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.MHSMPrivateLinkResource"]] = None, **kwargs): """ :keyword value: Array of private link resources. :paramtype value: list[~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateLinkResource] """ - super(MHSMPrivateLinkResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class MHSMPrivateLinkServiceConnectionState(msrest.serialization.Model): +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", "Disconnected". + 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. Known values are: "None". + 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'}, + "status": {"key": "status", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "actions_required": {"key": "actionsRequired", "type": "str"}, } def __init__( @@ -2126,64 +2021,61 @@ 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", "Disconnected". + 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. Known values are: "None". + updates on the consumer. "None" :paramtype actions_required: str or ~azure.mgmt.keyvault.v2022_07_01.models.ActionsRequired """ - super(MHSMPrivateLinkServiceConnectionState, self).__init__(**kwargs) + super().__init__(**kwargs) self.status = status self.description = description self.actions_required = actions_required -class MHSMVirtualNetworkRule(msrest.serialization.Model): +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 Azure. - :ivar id: Required. Full resource id of a vnet subnet, such as + :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}, + "id": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - *, - id: str, - **kwargs - ): + def __init__(self, *, id: str, **kwargs): # pylint: disable=redefined-builtin """ - :keyword id: Required. Full resource id of a vnet subnet, such as + :keyword id: Full resource id of a vnet subnet, such as '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. + Required. :paramtype id: str """ - super(MHSMVirtualNetworkRule, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id -class NetworkRuleSet(msrest.serialization.Model): +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", + '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", "Deny". + "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] @@ -2193,10 +2085,10 @@ class NetworkRuleSet(msrest.serialization.Model): """ _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]'}, + "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__( @@ -2210,12 +2102,12 @@ 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", + '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", "Deny". + 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] @@ -2223,14 +2115,14 @@ def __init__( :paramtype virtual_network_rules: list[~azure.mgmt.keyvault.v2022_07_01.models.VirtualNetworkRule] """ - super(NetworkRuleSet, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class Operation(_serialization.Model): """Key Vault REST API operation definition. :ivar name: Operation name: {provider}/{resource}/{operation}. @@ -2246,11 +2138,11 @@ class Operation(msrest.serialization.Model): """ _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'}, + "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__( @@ -2275,7 +2167,7 @@ def __init__( :keyword service_specification: One property of operation, include metric specifications. :paramtype service_specification: ~azure.mgmt.keyvault.v2022_07_01.models.ServiceSpecification """ - super(Operation, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display = display self.origin = origin @@ -2283,7 +2175,7 @@ def __init__( self.service_specification = service_specification -class OperationDisplay(msrest.serialization.Model): +class OperationDisplay(_serialization.Model): """Display metadata associated with the operation. :ivar provider: Service provider: Microsoft Key Vault. @@ -2297,10 +2189,10 @@ class OperationDisplay(msrest.serialization.Model): """ _attribute_map = { - 'provider': {'key': 'provider', 'type': 'str'}, - 'resource': {'key': 'resource', 'type': 'str'}, - 'operation': {'key': 'operation', 'type': 'str'}, - 'description': {'key': 'description', 'type': 'str'}, + "provider": {"key": "provider", "type": "str"}, + "resource": {"key": "resource", "type": "str"}, + "operation": {"key": "operation", "type": "str"}, + "description": {"key": "description", "type": "str"}, } def __init__( @@ -2322,14 +2214,14 @@ def __init__( :keyword description: Description of operation. :paramtype description: str """ - super(OperationDisplay, self).__init__(**kwargs) + super().__init__(**kwargs) self.provider = provider self.resource = resource self.operation = operation self.description = description -class OperationListResult(msrest.serialization.Model): +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. @@ -2339,29 +2231,23 @@ class OperationListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Operation]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(OperationListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class Permissions(msrest.serialization.Model): +class Permissions(_serialization.Model): """Permissions the identity has for keys, secrets, certificates and storage. :ivar keys: Permissions to keys. @@ -2376,10 +2262,10 @@ class Permissions(msrest.serialization.Model): """ _attribute_map = { - 'keys': {'key': 'keys', 'type': '[str]'}, - 'secrets': {'key': 'secrets', 'type': '[str]'}, - 'certificates': {'key': 'certificates', 'type': '[str]'}, - 'storage': {'key': 'storage', 'type': '[str]'}, + "keys": {"key": "keys", "type": "[str]"}, + "secrets": {"key": "secrets", "type": "[str]"}, + "certificates": {"key": "certificates", "type": "[str]"}, + "storage": {"key": "storage", "type": "[str]"}, } def __init__( @@ -2402,14 +2288,14 @@ def __init__( :keyword storage: Permissions to storage accounts. :paramtype storage: list[str or ~azure.mgmt.keyvault.v2022_07_01.models.StoragePermissions] """ - super(Permissions, self).__init__(**kwargs) + super().__init__(**kwargs) self.keys = keys self.secrets = secrets self.certificates = certificates self.storage = storage -class PrivateEndpoint(msrest.serialization.Model): +class PrivateEndpoint(_serialization.Model): """Private endpoint object properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -2419,20 +2305,16 @@ class PrivateEndpoint(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, + "id": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(PrivateEndpoint, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None @@ -2449,7 +2331,7 @@ class PrivateEndpointConnection(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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 @@ -2459,29 +2341,32 @@ class PrivateEndpointConnection(Resource): :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", "Disconnected". + 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}, + "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'}, + "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__( @@ -2502,18 +2387,18 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnectionProvisioningState """ - super(PrivateEndpointConnection, self).__init__(**kwargs) + 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(msrest.serialization.Model): +class PrivateEndpointConnectionItem(_serialization.Model): """Private endpoint connection item. :ivar id: Id of private endpoint connection. @@ -2526,23 +2411,26 @@ class PrivateEndpointConnectionItem(msrest.serialization.Model): :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", "Disconnected". + 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'}, + "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, + 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, @@ -2560,11 +2448,11 @@ def __init__( :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", "Disconnected". + values are: "Succeeded", "Creating", "Updating", "Deleting", "Failed", and "Disconnected". :paramtype provisioning_state: str or ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnectionProvisioningState """ - super(PrivateEndpointConnectionItem, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id self.etag = etag self.private_endpoint = private_endpoint @@ -2572,7 +2460,7 @@ def __init__( self.provisioning_state = provisioning_state -class PrivateEndpointConnectionListResult(msrest.serialization.Model): +class PrivateEndpointConnectionListResult(_serialization.Model): """List of private endpoint connections. :ivar value: The list of private endpoint connections. @@ -2582,8 +2470,8 @@ class PrivateEndpointConnectionListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[PrivateEndpointConnection]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[PrivateEndpointConnection]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( @@ -2599,7 +2487,7 @@ def __init__( :keyword next_link: The URL to get the next set of private endpoint connections. :paramtype next_link: str """ - super(PrivateEndpointConnectionListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link @@ -2617,7 +2505,7 @@ class PrivateLinkResource(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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 @@ -2628,43 +2516,38 @@ class PrivateLinkResource(Resource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'location': {'readonly': True}, - 'tags': {'readonly': True}, - 'group_id': {'readonly': True}, - 'required_members': {'readonly': True}, + "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]'}, + "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 - ): + def __init__(self, *, required_zone_names: Optional[List[str]] = None, **kwargs): """ :keyword required_zone_names: Required DNS zone names of the the private link resource. :paramtype required_zone_names: list[str] """ - super(PrivateLinkResource, self).__init__(**kwargs) + super().__init__(**kwargs) self.group_id = None self.required_members = None self.required_zone_names = required_zone_names -class PrivateLinkResourceListResult(msrest.serialization.Model): +class PrivateLinkResourceListResult(_serialization.Model): """A list of private link resources. :ivar value: Array of private link resources. @@ -2672,41 +2555,36 @@ class PrivateLinkResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[PrivateLinkResource]'}, + "value": {"key": "value", "type": "[PrivateLinkResource]"}, } - def __init__( - self, - *, - value: Optional[List["_models.PrivateLinkResource"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs): """ :keyword value: Array of private link resources. :paramtype value: list[~azure.mgmt.keyvault.v2022_07_01.models.PrivateLinkResource] """ - super(PrivateLinkResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class PrivateLinkServiceConnectionState(msrest.serialization.Model): +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", "Disconnected". + 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. Known values are: "None". + 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'}, + "status": {"key": "status", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "actions_required": {"key": "actionsRequired", "type": "str"}, } def __init__( @@ -2719,22 +2597,22 @@ 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", "Disconnected". + 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. Known values are: "None". + updates on the consumer. "None" :paramtype actions_required: str or ~azure.mgmt.keyvault.v2022_07_01.models.ActionsRequired """ - super(PrivateLinkServiceConnectionState, self).__init__(**kwargs) + super().__init__(**kwargs) self.status = status self.description = description self.actions_required = actions_required -class ResourceListResult(msrest.serialization.Model): +class ResourceListResult(_serialization.Model): """List of vault resources. :ivar value: The list of vault resources. @@ -2744,29 +2622,23 @@ class ResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Resource]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Resource"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(ResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class RotationPolicy(msrest.serialization.Model): +class RotationPolicy(_serialization.Model): """RotationPolicy. :ivar attributes: The attributes of key rotation policy. @@ -2776,8 +2648,8 @@ class RotationPolicy(msrest.serialization.Model): """ _attribute_map = { - 'attributes': {'key': 'attributes', 'type': 'KeyRotationPolicyAttributes'}, - 'lifetime_actions': {'key': 'lifetimeActions', 'type': '[LifetimeAction]'}, + "attributes": {"key": "attributes", "type": "KeyRotationPolicyAttributes"}, + "lifetime_actions": {"key": "lifetimeActions", "type": "[LifetimeAction]"}, } def __init__( @@ -2793,7 +2665,7 @@ def __init__( :keyword lifetime_actions: The lifetimeActions for key rotation action. :paramtype lifetime_actions: list[~azure.mgmt.keyvault.v2022_07_01.models.LifetimeAction] """ - super(RotationPolicy, self).__init__(**kwargs) + super().__init__(**kwargs) self.attributes = attributes self.lifetime_actions = lifetime_actions @@ -2813,41 +2685,36 @@ class Secret(Resource): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :ivar tags: Tags assigned to the key vault resource. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the secret. + :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}, + "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'}, + "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 - ): + def __init__(self, *, properties: "_models.SecretProperties", **kwargs): """ - :keyword properties: Required. Properties of the secret. + :keyword properties: Properties of the secret. Required. :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.SecretProperties """ - super(Secret, self).__init__(**kwargs) + super().__init__(**kwargs) self.properties = properties @@ -2869,16 +2736,16 @@ class SecretAttributes(Attributes): """ _validation = { - 'created': {'readonly': True}, - 'updated': {'readonly': True}, + "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'}, + "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__( @@ -2897,48 +2764,42 @@ def __init__( :keyword expires: Expiry date in seconds since 1970-01-01T00:00:00Z. :paramtype expires: ~datetime.datetime """ - super(SecretAttributes, self).__init__(enabled=enabled, not_before=not_before, expires=expires, **kwargs) + super().__init__(enabled=enabled, not_before=not_before, expires=expires, **kwargs) -class SecretCreateOrUpdateParameters(msrest.serialization.Model): +class SecretCreateOrUpdateParameters(_serialization.Model): """Parameters for creating or updating a secret. All required parameters must be populated in order to send to Azure. - :ivar tags: A set of tags. The tags that will be assigned to the secret. + :ivar tags: The tags that will be assigned to the secret. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the secret. + :ivar properties: Properties of the secret. Required. :vartype properties: ~azure.mgmt.keyvault.v2022_07_01.models.SecretProperties """ _validation = { - 'properties': {'required': True}, + "properties": {"required": True}, } _attribute_map = { - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'SecretProperties'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "SecretProperties"}, } - def __init__( - self, - *, - properties: "_models.SecretProperties", - tags: Optional[Dict[str, str]] = None, - **kwargs - ): + def __init__(self, *, properties: "_models.SecretProperties", tags: Optional[Dict[str, str]] = None, **kwargs): """ - :keyword tags: A set of tags. The tags that will be assigned to the secret. + :keyword tags: The tags that will be assigned to the secret. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the secret. + :keyword properties: Properties of the secret. Required. :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.SecretProperties """ - super(SecretCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class SecretListResult(msrest.serialization.Model): +class SecretListResult(_serialization.Model): """List of secrets. :ivar value: The list of secrets. @@ -2948,40 +2809,34 @@ class SecretListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Secret]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Secret"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(SecretListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class SecretPatchParameters(msrest.serialization.Model): +class SecretPatchParameters(_serialization.Model): """Parameters for patching a secret. - :ivar tags: A set of tags. The tags that will be assigned to the 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'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "SecretPatchProperties"}, } def __init__( @@ -2992,17 +2847,17 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. The tags that will be assigned to the secret. + :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(SecretPatchParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class SecretPatchProperties(msrest.serialization.Model): +class SecretPatchProperties(_serialization.Model): """Properties of the secret. :ivar value: The value of the secret. @@ -3014,9 +2869,9 @@ class SecretPatchProperties(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, - 'content_type': {'key': 'contentType', 'type': 'str'}, - 'attributes': {'key': 'attributes', 'type': 'SecretAttributes'}, + "value": {"key": "value", "type": "str"}, + "content_type": {"key": "contentType", "type": "str"}, + "attributes": {"key": "attributes", "type": "SecretAttributes"}, } def __init__( @@ -3035,13 +2890,13 @@ def __init__( :keyword attributes: The attributes of the secret. :paramtype attributes: ~azure.mgmt.keyvault.v2022_07_01.models.SecretAttributes """ - super(SecretPatchProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.content_type = content_type self.attributes = attributes -class SecretProperties(msrest.serialization.Model): +class SecretProperties(_serialization.Model): """Properties of the secret. Variables are only populated by the server, and will be ignored when sending a request. @@ -3061,16 +2916,16 @@ class SecretProperties(msrest.serialization.Model): """ _validation = { - 'secret_uri': {'readonly': True}, - 'secret_uri_with_version': {'readonly': True}, + "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'}, + "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__( @@ -3091,7 +2946,7 @@ def __init__( :keyword attributes: The attributes of the secret. :paramtype attributes: ~azure.mgmt.keyvault.v2022_07_01.models.SecretAttributes """ - super(SecretProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.content_type = content_type self.attributes = attributes @@ -3099,7 +2954,7 @@ def __init__( self.secret_uri_with_version = None -class ServiceSpecification(msrest.serialization.Model): +class ServiceSpecification(_serialization.Model): """One property of operation, include log specifications. :ivar log_specifications: Log specifications of operation. @@ -3110,8 +2965,8 @@ class ServiceSpecification(msrest.serialization.Model): """ _attribute_map = { - 'log_specifications': {'key': 'logSpecifications', 'type': '[LogSpecification]'}, - 'metric_specifications': {'key': 'metricSpecifications', 'type': '[MetricSpecification]'}, + "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, + "metric_specifications": {"key": "metricSpecifications", "type": "[MetricSpecification]"}, } def __init__( @@ -3128,78 +2983,72 @@ def __init__( :paramtype metric_specifications: list[~azure.mgmt.keyvault.v2022_07_01.models.MetricSpecification] """ - super(ServiceSpecification, self).__init__(**kwargs) + super().__init__(**kwargs) self.log_specifications = log_specifications self.metric_specifications = metric_specifications -class Sku(msrest.serialization.Model): +class Sku(_serialization.Model): """SKU details. All required parameters must be populated in order to send to Azure. - :ivar family: Required. SKU family name. Known values are: "A". + :ivar family: SKU family name. Required. "A" :vartype family: str or ~azure.mgmt.keyvault.v2022_07_01.models.SkuFamily - :ivar name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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}, + "family": {"required": True}, + "name": {"required": True}, } _attribute_map = { - 'family': {'key': 'family', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, + "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 - ): + def __init__(self, *, family: Union[str, "_models.SkuFamily"], name: Union[str, "_models.SkuName"], **kwargs): """ - :keyword family: Required. SKU family name. Known values are: "A". + :keyword family: SKU family name. Required. "A" :paramtype family: str or ~azure.mgmt.keyvault.v2022_07_01.models.SkuFamily - :keyword name: Required. SKU name to specify whether the key vault is a standard vault or a - premium vault. Known values are: "standard", "premium". + :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(Sku, self).__init__(**kwargs) + super().__init__(**kwargs) self.family = family self.name = name -class SystemData(msrest.serialization.Model): +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", "Key". + 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", "Key". + 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'}, + "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__( @@ -3217,19 +3066,19 @@ def __init__( :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", "Key". + 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", "Key". + 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(SystemData, self).__init__(**kwargs) + super().__init__(**kwargs) self.created_by = created_by self.created_by_type = created_by_type self.created_at = created_at @@ -3238,7 +3087,7 @@ def __init__( self.last_modified_at = last_modified_at -class Trigger(msrest.serialization.Model): +class Trigger(_serialization.Model): """Trigger. :ivar time_after_create: The time duration after key creation to rotate the key. It only @@ -3250,17 +3099,11 @@ class Trigger(msrest.serialization.Model): """ _attribute_map = { - 'time_after_create': {'key': 'timeAfterCreate', 'type': 'str'}, - 'time_before_expiry': {'key': 'timeBeforeExpiry', 'type': 'str'}, + "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 - ): + def __init__(self, *, time_after_create: Optional[str] = None, time_before_expiry: Optional[str] = None, **kwargs): """ :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'. @@ -3269,12 +3112,12 @@ def __init__( be in ISO 8601 duration format. Eg: 'P90D', 'P1Y'. :paramtype time_before_expiry: str """ - super(Trigger, self).__init__(**kwargs) + super().__init__(**kwargs) self.time_after_create = time_after_create self.time_before_expiry = time_before_expiry -class Vault(msrest.serialization.Model): +class Vault(_serialization.Model): """Resource information with extended details. Variables are only populated by the server, and will be ignored when sending a request. @@ -3289,30 +3132,30 @@ class Vault(msrest.serialization.Model): :vartype type: str :ivar location: Azure location of the key vault resource. :vartype location: str - :ivar tags: A set of tags. Tags assigned to the key vault resource. + :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: Required. Properties of the vault. + :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}, + "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'}, + "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__( @@ -3326,12 +3169,12 @@ def __init__( """ :keyword location: Azure location of the key vault resource. :paramtype location: str - :keyword tags: A set of tags. Tags assigned to the key vault resource. + :keyword tags: Tags assigned to the key vault resource. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.VaultProperties """ - super(Vault, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -3341,7 +3184,7 @@ def __init__( self.properties = properties -class VaultAccessPolicyParameters(msrest.serialization.Model): +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. @@ -3356,37 +3199,32 @@ class VaultAccessPolicyParameters(msrest.serialization.Model): :vartype type: str :ivar location: The resource type of the access policy. :vartype location: str - :ivar properties: Required. Properties of the access policy. + :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}, + "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'}, + "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 - ): + def __init__(self, *, properties: "_models.VaultAccessPolicyProperties", **kwargs): """ - :keyword properties: Required. Properties of the access policy. + :keyword properties: Properties of the access policy. Required. :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyProperties """ - super(VaultAccessPolicyParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -3394,127 +3232,112 @@ def __init__( self.properties = properties -class VaultAccessPolicyProperties(msrest.serialization.Model): +class VaultAccessPolicyProperties(_serialization.Model): """Properties of the vault access policy. All required parameters must be populated in order to send to Azure. - :ivar access_policies: Required. 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. + :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}, + "access_policies": {"required": True}, } _attribute_map = { - 'access_policies': {'key': 'accessPolicies', 'type': '[AccessPolicyEntry]'}, + "access_policies": {"key": "accessPolicies", "type": "[AccessPolicyEntry]"}, } - def __init__( - self, - *, - access_policies: List["_models.AccessPolicyEntry"], - **kwargs - ): + def __init__(self, *, access_policies: List["_models.AccessPolicyEntry"], **kwargs): """ - :keyword access_policies: Required. 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. + :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(VaultAccessPolicyProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.access_policies = access_policies -class VaultCheckNameAvailabilityParameters(msrest.serialization.Model): +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 Azure. - :ivar name: Required. The vault name. + :ivar name: The vault name. Required. :vartype name: str - :ivar type: The type of resource, Microsoft.KeyVault/vaults. Has constant value: + :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}, + "name": {"required": True}, + "type": {"required": True, "constant": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, } type = "Microsoft.KeyVault/vaults" - def __init__( - self, - *, - name: str, - **kwargs - ): + def __init__(self, *, name: str, **kwargs): """ - :keyword name: Required. The vault name. + :keyword name: The vault name. Required. :paramtype name: str """ - super(VaultCheckNameAvailabilityParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name -class VaultCreateOrUpdateParameters(msrest.serialization.Model): +class VaultCreateOrUpdateParameters(_serialization.Model): """Parameters for creating or updating a vault. All required parameters must be populated in order to send to Azure. - :ivar location: Required. The supported Azure location where the key vault should be created. + :ivar location: The supported Azure location where the key vault should be created. Required. :vartype location: str - :ivar tags: A set of tags. The tags that will be assigned to the key vault. + :ivar tags: The tags that will be assigned to the key vault. :vartype tags: dict[str, str] - :ivar properties: Required. Properties of the vault. + :ivar properties: Properties of the vault. Required. :vartype properties: ~azure.mgmt.keyvault.v2022_07_01.models.VaultProperties """ _validation = { - 'location': {'required': True}, - 'properties': {'required': True}, + "location": {"required": True}, + "properties": {"required": True}, } _attribute_map = { - 'location': {'key': 'location', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'properties': {'key': 'properties', 'type': 'VaultProperties'}, + "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 + self, *, location: str, properties: "_models.VaultProperties", tags: Optional[Dict[str, str]] = None, **kwargs ): """ - :keyword location: Required. The supported Azure location where the key vault should be - created. + :keyword location: The supported Azure location where the key vault should be created. + Required. :paramtype location: str - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :keyword tags: The tags that will be assigned to the key vault. :paramtype tags: dict[str, str] - :keyword properties: Required. Properties of the vault. + :keyword properties: Properties of the vault. Required. :paramtype properties: ~azure.mgmt.keyvault.v2022_07_01.models.VaultProperties """ - super(VaultCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.location = location self.tags = tags self.properties = properties -class VaultListResult(msrest.serialization.Model): +class VaultListResult(_serialization.Model): """List of vaults. :ivar value: The list of vaults. @@ -3524,40 +3347,34 @@ class VaultListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Vault]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "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 - ): + def __init__(self, *, value: Optional[List["_models.Vault"]] = None, next_link: Optional[str] = None, **kwargs): """ :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(VaultListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class VaultPatchParameters(msrest.serialization.Model): +class VaultPatchParameters(_serialization.Model): """Parameters for creating or updating a vault. - :ivar tags: A set of tags. The tags that will be assigned to the key 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'}, + "tags": {"key": "tags", "type": "{str}"}, + "properties": {"key": "properties", "type": "VaultPatchProperties"}, } def __init__( @@ -3568,17 +3385,17 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. The tags that will be assigned to the key vault. + :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(VaultPatchParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.properties = properties -class VaultPatchProperties(msrest.serialization.Model): +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 @@ -3611,7 +3428,7 @@ class VaultPatchProperties(msrest.serialization.Model): :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", "default". + 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 @@ -3630,19 +3447,19 @@ class VaultPatchProperties(msrest.serialization.Model): """ _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'}, + "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__( @@ -3695,7 +3512,7 @@ def __init__( <=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", "default". + 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 @@ -3712,7 +3529,7 @@ def __init__( meaning that even if the firewall rules are present we will not honor the rules. :paramtype public_network_access: str """ - super(VaultPatchProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies @@ -3728,17 +3545,17 @@ def __init__( self.public_network_access = public_network_access -class VaultProperties(msrest.serialization.Model): +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 Azure. - :ivar tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :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 @@ -3772,7 +3589,7 @@ class VaultProperties(msrest.serialization.Model): 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", "default". + 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 @@ -3783,7 +3600,7 @@ class VaultProperties(msrest.serialization.Model): :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", + :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 @@ -3799,30 +3616,33 @@ class VaultProperties(msrest.serialization.Model): """ _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'}, + "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__( @@ -3835,21 +3655,21 @@ def __init__( 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] = True, - soft_delete_retention_in_days: Optional[int] = 90, - enable_rbac_authorization: Optional[bool] = False, + 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: Optional[str] = "enabled", + public_network_access: str = "enabled", **kwargs ): """ - :keyword tenant_id: Required. The Azure Active Directory tenant ID that should be used for - authenticating requests to the key vault. + :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: Required. SKU details. + :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 @@ -3882,7 +3702,7 @@ def __init__( 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", "default". + 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 @@ -3893,7 +3713,7 @@ def __init__( :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", + :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 @@ -3903,7 +3723,7 @@ def __init__( meaning that even if the firewall rules are present we will not honor the rules. :paramtype public_network_access: str """ - super(VaultProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tenant_id = tenant_id self.sku = sku self.access_policies = access_policies @@ -3923,13 +3743,14 @@ def __init__( self.public_network_access = public_network_access -class VirtualNetworkRule(msrest.serialization.Model): +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 Azure. - :ivar id: Required. Full resource id of a vnet subnet, such as + :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. @@ -3937,29 +3758,30 @@ class VirtualNetworkRule(msrest.serialization.Model): """ _validation = { - 'id': {'required': True}, + "id": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'ignore_missing_vnet_service_endpoint': {'key': 'ignoreMissingVnetServiceEndpoint', 'type': 'bool'}, + "id": {"key": "id", "type": "str"}, + "ignore_missing_vnet_service_endpoint": {"key": "ignoreMissingVnetServiceEndpoint", "type": "bool"}, } def __init__( self, *, - id: str, + id: str, # pylint: disable=redefined-builtin ignore_missing_vnet_service_endpoint: Optional[bool] = None, **kwargs ): """ - :keyword id: Required. Full resource id of a vnet subnet, such as + :keyword id: Full resource id of a vnet subnet, such as '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. + 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(VirtualNetworkRule, self).__init__(**kwargs) + 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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 index 49be258e3efc..9e5cd053e465 100644 --- 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 @@ -19,16 +19,17 @@ from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'KeysOperations', - 'VaultsOperations', - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'ManagedHsmsOperations', - 'MHSMPrivateEndpointConnectionsOperations', - 'MHSMPrivateLinkResourcesOperations', - 'Operations', - 'SecretsOperations', + "KeysOperations", + "VaultsOperations", + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "ManagedHsmsOperations", + "MHSMPrivateEndpointConnectionsOperations", + "MHSMPrivateLinkResourcesOperations", + "Operations", + "SecretsOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_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/v2022_07_01/operations/_keys_operations.py index 8d959b0065cf..b5e2e54bcf87 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/v2022_07_01/operations/_keys_operations.py @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -20,214 +26,176 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - *, - json: Optional[_models.KeyCreateParameters] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_version_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - key_version: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_versions_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class KeysOperations: """ @@ -248,14 +216,15 @@ def __init__(self, *args, **kwargs): 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") - - @distributed_trace + @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 @@ -263,42 +232,126 @@ def create_if_not_exist( subsequent versions, and does not update existing keys. :param resource_group_name: The name of the resource group which contains the specified key - vault. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the key vault which contains the key to be created. + :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. + :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. + :param parameters: The parameters used to create the specified key. Required. :type parameters: ~azure.mgmt.keyvault.v2022_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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_if_not_exist( + self, + resource_group_name: str, + vault_name: str, + key_name: str, + parameters: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Key or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2022_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], + **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 model type or a + IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.KeyCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Key or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - _json = self._serialize.body(parameters, 'KeyCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "KeyCreateParameters") request = build_create_if_not_exist_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.create_if_not_exist.metadata['url'], + content=_content, + template_url=self.create_if_not_exist.metadata["url"], headers=_headers, params=_params, ) @@ -306,67 +359,61 @@ def create_if_not_exist( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_if_not_exist.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + create_if_not_exist.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> _models.Key: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the key to be retrieved. + :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. + :param key_name: The name of the key to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -374,64 +421,61 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}"} # type: ignore @distributed_trace - def list( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> Iterable[_models.KeyListResult]: + 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. + vault. Required. :type resource_group_name: str - :param vault_name: The name of the vault which contains the keys to be retrieved. + :param vault_name: The name of the vault which contains the keys to be retrieved. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -439,15 +483,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -464,10 +510,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -477,57 +521,53 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys"} # type: ignore @distributed_trace def get_version( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - key_version: str, - **kwargs: Any + 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. + 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. + :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. + :param key_version: The version of the key to be retrieved. Required. :type key_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Key, or the result of cls(response) + :return: Key or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Key - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Key] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Key] - request = build_get_version_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get_version.metadata['url'], + template_url=self.get_version.metadata["url"], headers=_headers, params=_params, ) @@ -535,68 +575,67 @@ def get_version( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Key", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_version.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore - + get_version.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions/{keyVersion}"} # type: ignore @distributed_trace def list_versions( - self, - resource_group_name: str, - vault_name: str, - key_name: str, - **kwargs: Any - ) -> Iterable[_models.KeyListResult]: + 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. + 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. + :param key_name: The name of the key versions to be retrieved. Required. :type key_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either KeyListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.KeyListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_versions_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, key_name=key_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_versions.metadata['url'], + template_url=self.list_versions.metadata["url"], headers=_headers, params=_params, ) @@ -604,16 +643,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_versions_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - key_name=key_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -630,10 +670,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -643,8 +681,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_versions.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore + list_versions.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/keys/{keyName}/versions"} # type: ignore 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 index 393a8e1e65bc..8c461dd18480 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,399 +28,310 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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_initial( - resource_group_name: str, - name: str, - subscription_id: str, - *, - json: Optional[_models.ManagedHsm] = None, - content: Any = None, - **kwargs: Any + +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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) - - -def build_update_request_initial( - resource_group_name: str, - name: str, - subscription_id: str, - *, - json: Optional[_models.ManagedHsm] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) - - -def build_delete_request_initial( - resource_group_name: str, - name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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["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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_list_deleted_request( - subscription_id: str, - **kwargs: Any -) -> HttpRequest: +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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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["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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "name": _SERIALIZER.url("name", name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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_initial( - name: str, - location: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + _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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "name": _SERIALIZER.url("name", name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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( - subscription_id: str, - *, - json: Optional[_models.CheckMhsmNameAvailabilityParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + _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(subscription_id: str, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkMhsmNameAvailability") # pylint: disable=line-too-long + _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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: """ @@ -435,36 +352,41 @@ def __init__(self, *args, **kwargs): 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") - def _create_or_update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -472,49 +394,119 @@ def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + 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 = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - - deserialized = self._deserialize('ManagedHsm', pipeline_response) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - - @distributed_trace + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to create or update the managed HSM Pool. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], **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 model type + or a IO type. Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -525,20 +517,17 @@ def begin_create_or_update( Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -546,69 +535,71 @@ def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore def _update_initial( - self, - resource_group_name: str, - name: str, - parameters: _models.ManagedHsm, - **kwargs: Any + self, resource_group_name: str, name: str, parameters: Union[_models.ManagedHsm, IO], **kwargs: Any ) -> _models.ManagedHsm: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] - _json = self._serialize.body(parameters, 'ManagedHsm') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ManagedHsm") - request = build_update_request_initial( + 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, - template_url=self._update_initial.metadata['url'], + content=_content, + template_url=self._update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -616,49 +607,119 @@ def _update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + 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 = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if response.status_code == 202: - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - - deserialized = self._deserialize('ManagedHsm', pipeline_response) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + _update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - - @distributed_trace + @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. + :param name: Name of the managed HSM Pool. Required. :type name: str - :param parameters: Parameters to patch the managed HSM Pool. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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], **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsm or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -669,20 +730,17 @@ def begin_update( Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsm] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsm] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._update_initial( # type: ignore resource_group_name=resource_group_name, @@ -690,64 +748,59 @@ def begin_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore def _delete_initial( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any + self, resource_group_name: str, name: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_delete_request_initial( + request = build_delete_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -755,39 +808,33 @@ def _delete_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **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) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} if response.status_code == 202: - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, None, response_headers) - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace - def begin_delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param name: The name of the managed HSM Pool to delete. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -799,92 +846,83 @@ def begin_delete( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore resource_group_name=resource_group_name, name=name, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> Optional[_models.ManagedHsm]: + 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. + :param name: The name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ManagedHsm, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.ManagedHsm]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.ManagedHsm]] - request = build_get_request( resource_group_name=resource_group_name, name=name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -892,10 +930,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -905,56 +942,55 @@ def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('ManagedHsm', pipeline_response) + deserialized = self._deserialize("ManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -962,15 +998,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -987,10 +1025,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1001,48 +1037,44 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.ManagedHsmListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ManagedHsmListResult or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.ManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -1050,14 +1082,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1074,10 +1109,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1088,44 +1121,41 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/managedHSMs"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> Iterable[_models.DeletedManagedHsmListResult]: + def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedManagedHsm"]: """The List operation gets information about the deleted managed HSMs associated with the subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedManagedHsmListResult or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.DeletedManagedHsmListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsmListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsmListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1133,13 +1163,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1156,10 +1190,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1170,48 +1202,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedManagedHSMs"} # type: ignore @distributed_trace - def get_deleted( - self, - name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedManagedHsm: + 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. + :param name: The name of the deleted managed HSM. Required. :type name: str - :param location: The location of the deleted managed HSM. + :param location: The location of the deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedManagedHsm, or the result of cls(response) + :return: DeletedManagedHsm or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.DeletedManagedHsm - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedManagedHsm] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedManagedHsm] - request = build_get_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1219,10 +1246,9 @@ def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -1230,40 +1256,38 @@ def get_deleted( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DeletedManagedHsm', pipeline_response) + deserialized = self._deserialize("DeletedManagedHsm", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}"} # type: ignore def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any + self, name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( name=name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -1271,38 +1295,31 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + 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')) - + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, None, response_headers) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore @distributed_trace - def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - name: str, - location: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param name: The name of the soft-deleted managed HSM. Required. :type name: str - :param location: The location of the soft-deleted managed HSM. + :param location: The location of the soft-deleted managed HSM. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -1314,91 +1331,134 @@ def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._purge_deleted_initial( # type: ignore name=name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedManagedHSMs/{name}/purge"} # type: ignore - @distributed_trace + @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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], **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 model type or a IO type. Required. + :type mhsm_name: ~azure.mgmt.keyvault.v2022_07_01.models.CheckMhsmNameAvailabilityParameters or + IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckMhsmNameAvailabilityResult, or the result of cls(response) + :return: CheckMhsmNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckMhsmNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckMhsmNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckMhsmNameAvailabilityResult] - _json = self._serialize.body(mhsm_name, 'CheckMhsmNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(mhsm_name, (IO, 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, - template_url=self.check_mhsm_name_availability.metadata['url'], + content=_content, + template_url=self.check_mhsm_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1406,22 +1466,20 @@ def check_mhsm_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckMhsmNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_mhsm_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkMhsmNameAvailability"} # type: ignore - + check_mhsm_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkMhsmNameAvailability"} # 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 index db9df649cb8e..bdac7ebe1523 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,173 +28,151 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - subscription_id: str, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_put_request( - subscription_id: str, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - *, - json: Optional[_models.MHSMPrivateEndpointConnection] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) - - -def build_delete_request_initial( - subscription_id: str, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + _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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class MHSMPrivateEndpointConnectionsOperations: """ @@ -209,47 +193,48 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def list_by_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any - ) -> Iterable[_models.MHSMPrivateEndpointConnectionsListResult]: + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either MHSMPrivateEndpointConnectionsListResult or the - result of cls(response) + :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.MHSMPrivateEndpointConnectionsListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnectionsListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -257,15 +242,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - name=name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -282,10 +269,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -296,53 +281,50 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -350,10 +332,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -361,64 +342,142 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ManagedHsmError, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - @distributed_trace + @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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateEndpointConnection, or the result of cls(response) + :return: MHSMPrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def put( + self, + resource_group_name: str, + name: str, + private_endpoint_connection_name: str, + properties: IO, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: MHSMPrivateEndpointConnection or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - _json = self._serialize.body(properties, 'MHSMPrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "MHSMPrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -426,10 +485,9 @@ def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -437,45 +495,44 @@ def put( 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')) + 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) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore def _delete_initial( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.MHSMPrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.MHSMPrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -483,10 +540,9 @@ def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -496,36 +552,31 @@ def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if response.status_code == 202: - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def begin_delete( - self, - resource_group_name: str, - name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + with the managed hsm pool. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -539,55 +590,48 @@ def begin_delete( result of cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('MHSMPrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("MHSMPrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateEndpointConnections/{privateEndpointConnectionName}"} # 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 index b2cc03ed3603..30bdcb76e9c9 100644 --- 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 @@ -8,9 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,48 +24,46 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class MHSMPrivateLinkResourcesOperations: """ @@ -81,43 +84,42 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def list_by_mhsm_resource( - self, - resource_group_name: str, - name: str, - **kwargs: Any + 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. + :param name: Name of the managed HSM Pool. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MHSMPrivateLinkResourceListResult, or the result of cls(response) + :return: MHSMPrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.MHSMPrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MHSMPrivateLinkResourceListResult] - request = build_list_by_mhsm_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, name=name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_mhsm_resource.metadata['url'], + template_url=self.list_by_mhsm_resource.metadata["url"], headers=_headers, params=_params, ) @@ -125,22 +127,20 @@ def list_by_mhsm_resource( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("MHSMPrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_mhsm_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # type: ignore - + list_by_mhsm_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/privateLinkResources"} # 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 index 3ebfef128be1..37906897e72f 100644 --- 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 @@ -7,10 +7,16 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +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.pipeline.transport import HttpResponse @@ -20,38 +26,34 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request -T = TypeVar('T') + +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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class Operations: """ @@ -72,36 +74,35 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> Iterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: """Lists all of the available Key Vault Rest API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -109,12 +110,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -131,10 +137,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -144,8 +148,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.KeyVault/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.KeyVault/operations"} # type: ignore 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 index 0ad201a8c586..f7dd32510333 100644 --- 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 @@ -10,6 +10,7 @@ __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. 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/v2022_07_01/operations/_private_endpoint_connections_operations.py index 3c439a2e0dc0..5421b8de33d9 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/v2022_07_01/operations/_private_endpoint_connections_operations.py @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,173 +28,163 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_put_request( - subscription_id: str, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, - *, - json: Optional[_models.PrivateEndpointConnection] = None, - content: Any = None, + subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) -def build_delete_request_initial( - subscription_id: str, +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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_resource_request( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateEndpointConnectionsOperations: """ @@ -209,48 +205,45 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def get( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :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 + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - request = build_get_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -258,10 +251,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -270,64 +262,139 @@ def get( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - @distributed_trace + @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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str - :param properties: The intended state of private endpoint connection. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :return: PrivateEndpointConnection or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2022_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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: PrivateEndpointConnection or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2022_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], + **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 model type or + a IO type. Required. + :type properties: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - _json = self._serialize.body(properties, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IO, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "PrivateEndpointConnection") request = build_put_request( - subscription_id=self._config.subscription_id, 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, - template_url=self.put.metadata['url'], + content=_content, + template_url=self.put.metadata["url"], headers=_headers, params=_params, ) @@ -335,10 +402,9 @@ def put( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -346,45 +412,44 @@ def put( 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')) + 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) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - put.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + put.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore def _delete_initial( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + self, resource_group_name: str, vault_name: str, private_endpoint_connection_name: str, **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + 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, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -392,10 +457,9 @@ def _delete_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: @@ -405,37 +469,31 @@ def _delete_initial( deserialized = None response_headers = {} if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) 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')) - + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def begin_delete( - self, - resource_group_name: str, - vault_name: str, - private_endpoint_connection_name: str, - **kwargs: Any + 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. + :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. + :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. + with the key vault. Required. :type private_endpoint_connection_name: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -449,99 +507,93 @@ def begin_delete( of cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2022_07_01.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore 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, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace def list_by_resource( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> Iterable[_models.PrivateEndpointConnectionListResult]: + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either PrivateEndpointConnectionListResult or the result - of cls(response) + :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.PrivateEndpointConnectionListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.paging.ItemPaged[~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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnectionListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource.metadata['url'], + template_url=self.list_by_resource.metadata["url"], headers=_headers, params=_params, ) @@ -549,15 +601,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - vault_name=vault_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -574,10 +628,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -587,8 +639,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore + list_by_resource.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateEndpointConnections"} # type: ignore 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 index eb18b2f17722..8bb114a6c5e2 100644 --- 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 @@ -8,9 +8,14 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,48 +24,46 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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( - subscription_id: str, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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}$'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateLinkResourcesOperations: """ @@ -81,43 +84,41 @@ def __init__(self, *args, **kwargs): 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") - @distributed_trace def list_by_vault( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :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. + :param vault_name: The name of the key vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateLinkResourceListResult, or the result of cls(response) + :return: PrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.PrivateLinkResourceListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] - request = build_list_by_vault_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, vault_name=vault_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_vault.metadata['url'], + template_url=self.list_by_vault.metadata["url"], headers=_headers, params=_params, ) @@ -125,22 +126,20 @@ def list_by_vault( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_vault.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # type: ignore - + list_by_vault.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/privateLinkResources"} # 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 index aad5f22b46c0..58e8d0806220 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -20,185 +26,150 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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, - *, - json: Optional[_models.SecretCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + 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, - *, - json: Optional[_models.SecretPatchParameters] = None, - content: Any = None, - **kwargs: Any + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _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, - json=json, - content=content, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + 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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class SecretsOperations: """ @@ -219,14 +190,15 @@ def __init__(self, *args, **kwargs): 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") - - @distributed_trace + @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 @@ -234,31 +206,115 @@ def create_or_update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.SecretCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -268,7 +324,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -276,10 +333,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -287,26 +343,27 @@ def create_or_update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - @distributed_trace + @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 @@ -314,31 +371,109 @@ def update( 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param secret_name: Name of the secret. + :param secret_name: Name of the secret. Required. :type secret_name: str - :param parameters: Parameters to patch the secret. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.SecretPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - _json = self._serialize.body(parameters, 'SecretPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SecretPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -348,7 +483,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -356,10 +492,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -367,60 +502,56 @@ def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Secret', pipeline_response) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - secret_name: str, - **kwargs: Any - ) -> _models.Secret: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param secret_name: The name of the secret. + :param secret_name: The name of the secret. Required. :type secret_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Secret, or the result of cls(response) + :return: Secret or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Secret - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Secret] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Secret] - 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, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -428,69 +559,68 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Secret", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets/{secretName}"} # type: ignore @distributed_trace def list( - self, - resource_group_name: str, - vault_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.SecretListResult]: + 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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SecretListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.SecretListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SecretListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SecretListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, top=top, - template_url=self.list.metadata['url'], + api_version=api_version, + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -498,16 +628,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - resource_group_name=resource_group_name, - vault_name=vault_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -524,10 +655,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -537,8 +666,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/secrets"} # type: ignore 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 index 6b2d11437595..2b953aef8188 100644 --- 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 @@ -6,11 +6,17 @@ # 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, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, 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.pipeline.transport import HttpResponse @@ -22,485 +28,377 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from ..._serialization import Serializer from .._vendor import _convert_request, _format_url_section -T = TypeVar('T') + +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_initial( - resource_group_name: str, - vault_name: str, - subscription_id: str, - *, - json: Optional[_models.VaultCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + +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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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, - *, - json: Optional[_models.VaultPatchParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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"], + operation_kind: Union[str, _models.AccessPolicyUpdateKind], subscription_id: str, - *, - json: Optional[_models.VaultAccessPolicyParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + 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 + _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'), + "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 = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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 + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_purge_deleted_request_initial( - vault_name: str, - location: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + 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 + _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'), + "vaultName": _SERIALIZER.url("vault_name", vault_name, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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 - ) + _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: + +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 = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - accept = _headers.pop('Accept', "application/json") + filter = kwargs.pop("filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) # type: str + 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'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') + _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') + _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 - ) + _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, - *, - json: Optional[_models.VaultCheckNameAvailabilityParameters] = None, - content: Any = None, - **kwargs: Any -) -> HttpRequest: + +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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability") + _url = kwargs.pop( + "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability" + ) path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _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, - json=json, - content=content, - **kwargs - ) + _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: """ @@ -521,36 +419,45 @@ def __init__(self, *args, **kwargs): 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") - def _create_or_update_initial( self, resource_group_name: str, vault_name: str, - parameters: _models.VaultCreateOrUpdateParameters, + parameters: Union[_models.VaultCreateOrUpdateParameters, IO], **kwargs: Any ) -> _models.Vault: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + 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, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -558,10 +465,9 @@ def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -569,35 +475,75 @@ def _create_or_update_initial( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to create or update the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -608,20 +554,51 @@ def begin_create_or_update( Retry-After header is present. :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 + :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], + **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 model type or a IO + type. Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -629,74 +606,140 @@ def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - @distributed_trace + @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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param parameters: Parameters to patch the vault. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def update( + self, + resource_group_name: str, + vault_name: str, + parameters: Union[_models.VaultPatchParameters, IO], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultPatchParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Vault or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Vault + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - _json = self._serialize.body(parameters, 'VaultPatchParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultPatchParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -705,7 +748,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -713,10 +757,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -724,55 +767,54 @@ def update( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Vault', pipeline_response) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any + 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. + :param vault_name: The name of the vault to delete. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[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, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -780,10 +822,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -793,45 +834,42 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - vault_name: str, - **kwargs: Any - ) -> _models.Vault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Vault, or the result of cls(response) + :return: Vault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.Vault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Vault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Vault] - request = build_get_request( resource_group_name=resource_group_name, vault_name=vault_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -839,63 +877,140 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("Vault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"} # type: ignore - - @distributed_trace + @overload def update_access_policy( self, resource_group_name: str, vault_name: str, - operation_kind: Union[str, "_models.AccessPolicyUpdateKind"], + 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. + :param vault_name: Name of the vault. Required. :type vault_name: str - :param operation_kind: Name of the operation. + :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. + :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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: VaultAccessPolicyParameters, or the result of cls(response) + :return: VaultAccessPolicyParameters or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters - :raises: ~azure.core.exceptions.HttpResponseError + :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, + *, + 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], + **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 model type or a IO type. + Required. + :type parameters: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: VaultAccessPolicyParameters or the result of cls(response) + :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.VaultAccessPolicyParameters + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultAccessPolicyParameters] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultAccessPolicyParameters] - _json = self._serialize.body(parameters, 'VaultAccessPolicyParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VaultAccessPolicyParameters") request = build_update_access_policy_request( resource_group_name=resource_group_name, @@ -905,7 +1020,8 @@ def update_access_policy( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update_access_policy.metadata['url'], + content=_content, + template_url=self.update_access_policy.metadata["url"], headers=_headers, params=_params, ) @@ -913,10 +1029,9 @@ def update_access_policy( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -924,57 +1039,58 @@ def update_access_policy( raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('VaultAccessPolicyParameters', pipeline_response) + deserialized = self._deserialize("VaultAccessPolicyParameters", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update_access_policy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore - + update_access_policy.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}/accessPolicies/{operationKind}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_resource_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -982,15 +1098,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1007,10 +1125,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1020,45 +1136,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_by_subscription( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.VaultListResult]: + 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 :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VaultListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.VaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - api_version=api_version, top=top, - template_url=self.list_by_subscription.metadata['url'], + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) @@ -1066,14 +1180,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1090,10 +1207,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1103,43 +1218,40 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_subscription.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/vaults"} # type: ignore @distributed_trace - def list_deleted( - self, - **kwargs: Any - ) -> Iterable[_models.DeletedVaultListResult]: + def list_deleted(self, **kwargs: Any) -> Iterable["_models.DeletedVault"]: """Gets information about the deleted vaults in a subscription. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DeletedVaultListResult or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.DeletedVaultListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVaultListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVaultListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - template_url=self.list_deleted.metadata['url'], + template_url=self.list_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1147,13 +1259,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_deleted_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1170,10 +1286,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1183,48 +1297,43 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore + list_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/deletedVaults"} # type: ignore @distributed_trace - def get_deleted( - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> _models.DeletedVault: + 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. + :param vault_name: The name of the vault. Required. :type vault_name: str - :param location: The location of the deleted vault. + :param location: The location of the deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DeletedVault, or the result of cls(response) + :return: DeletedVault or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.DeletedVault - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DeletedVault] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedVault] - request = build_get_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_deleted.metadata['url'], + template_url=self.get_deleted.metadata["url"], headers=_headers, params=_params, ) @@ -1232,50 +1341,47 @@ def get_deleted( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("DeletedVault", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore - + get_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}"} # type: ignore def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any + self, vault_name: str, location: str, **kwargs: Any ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_purge_deleted_request_initial( + request = build_purge_deleted_request( vault_name=vault_name, location=location, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._purge_deleted_initial.metadata['url'], + template_url=self._purge_deleted_initial.metadata["url"], headers=_headers, params=_params, ) @@ -1283,10 +1389,9 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: @@ -1296,21 +1401,15 @@ def _purge_deleted_initial( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - _purge_deleted_initial.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore - + _purge_deleted_initial.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace - def begin_purge_deleted( # pylint: disable=inconsistent-return-statements - self, - vault_name: str, - location: str, - **kwargs: Any - ) -> LROPoller[None]: + 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. + :param vault_name: The name of the soft-deleted vault. Required. :type vault_name: str - :param location: The location of the soft-deleted vault. + :param location: The location of the soft-deleted vault. Required. :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -1322,62 +1421,51 @@ def begin_purge_deleted( # pylint: disable=inconsistent-return-statements Retry-After header is present. :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 + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._purge_deleted_initial( # type: ignore vault_name=vault_name, location=location, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purge_deleted.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore + begin_purge_deleted.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge"} # type: ignore @distributed_trace - def list( - self, - top: Optional[int] = None, - **kwargs: Any - ) -> Iterable[_models.ResourceListResult]: + 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. @@ -1390,31 +1478,36 @@ def list( that overriding this default value may result in unsupported behavior. :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceListResult or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.keyvault.v2022_07_01.models.ResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :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 = kwargs.pop('filter', _params.pop('$filter', "resourceType eq 'Microsoft.KeyVault/vaults'")) # type: str - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-11-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ResourceListResult] + filter = kwargs.pop( + "filter", _params.pop("$filter", "resourceType eq 'Microsoft.KeyVault/vaults'") + ) # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", "2015-11-01")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceListResult] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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, - top=top, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -1422,15 +1515,17 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - filter=filter, - api_version=api_version, - top=top, - template_url=next_link, - headers=_headers, - params=_params, + # 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._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore @@ -1447,10 +1542,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -1460,47 +1553,95 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/resources"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/resources"} # type: ignore - @distributed_trace + @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. + :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 + :keyword callable cls: A custom type or function that will be passed the direct response + :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, *, 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 + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :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], **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 model type or a IO type. Required. :type vault_name: ~azure.mgmt.keyvault.v2022_07_01.models.VaultCheckNameAvailabilityParameters + or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: CheckNameAvailabilityResult, or the result of cls(response) + :return: CheckNameAvailabilityResult or the result of cls(response) :rtype: ~azure.mgmt.keyvault.v2022_07_01.models.CheckNameAvailabilityResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {}) or {}) + 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 = kwargs.pop('api_version', _params.pop('api-version', "2022-07-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.CheckNameAvailabilityResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-07-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CheckNameAvailabilityResult] - _json = self._serialize.body(vault_name, 'VaultCheckNameAvailabilityParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(vault_name, (IO, 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, - template_url=self.check_name_availability.metadata['url'], + content=_content, + template_url=self.check_name_availability.metadata["url"], headers=_headers, params=_params, ) @@ -1508,22 +1649,20 @@ def check_name_availability( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = 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) + deserialized = self._deserialize("CheckNameAvailabilityResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - check_name_availability.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore - + check_name_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkNameAvailability"} # type: ignore