diff --git a/sdk/keyvault/azure-keyvault-certificates/CHANGELOG.md b/sdk/keyvault/azure-keyvault-certificates/CHANGELOG.md index 8252bcd1a134..355273b2e97f 100644 --- a/sdk/keyvault/azure-keyvault-certificates/CHANGELOG.md +++ b/sdk/keyvault/azure-keyvault-certificates/CHANGELOG.md @@ -1,10 +1,11 @@ # Release History -## 4.10.1 (Unreleased) +## 4.11.0 (2026-03-11) ### Features Added -### Breaking Changes +- Added `uris` and `ip_addresses` properties to `SubjectAlternativeNames` model to support Uniform Resource + Identifiers and IP addresses (IPv4 and IPv6) in certificate subject alternative names ### Bugs Fixed @@ -14,7 +15,6 @@ serialized instead of raising an exception ([Azure/azure-cli #31764](https://github.com/Azure/azure-cli/issues/31764)) -### Other Changes ## 4.10.0 (2025-06-16) diff --git a/sdk/keyvault/azure-keyvault-certificates/_metadata.json b/sdk/keyvault/azure-keyvault-certificates/_metadata.json new file mode 100644 index 000000000000..73ffd72c94f7 --- /dev/null +++ b/sdk/keyvault/azure-keyvault-certificates/_metadata.json @@ -0,0 +1,10 @@ +{ + "apiVersion": "2025-07-01", + "apiVersions": { + "KeyVault": "2025-07-01" + }, + "commit": "48e2c462287288d03adad21e682404d90375462e", + "repository_url": "https://github.com/Azure/azure-rest-api-specs", + "typespec_src": "specification/keyvault/Security.KeyVault.Certificates", + "emitterVersion": "0.60.2" +} \ No newline at end of file diff --git a/sdk/keyvault/azure-keyvault-certificates/apiview-properties.json b/sdk/keyvault/azure-keyvault-certificates/apiview-properties.json new file mode 100644 index 000000000000..a914a0c1052b --- /dev/null +++ b/sdk/keyvault/azure-keyvault-certificates/apiview-properties.json @@ -0,0 +1,98 @@ +{ + "CrossLanguagePackageId": "KeyVault", + "CrossLanguageDefinitionId": { + "azure.keyvault.certificates._generated.models.Action": "KeyVault.Action", + "azure.keyvault.certificates._generated.models.AdministratorDetails": "KeyVault.AdministratorDetails", + "azure.keyvault.certificates._generated.models.BackupCertificateResult": "KeyVault.BackupCertificateResult", + "azure.keyvault.certificates._generated.models.CertificateAttributes": "KeyVault.CertificateAttributes", + "azure.keyvault.certificates._generated.models.CertificateBundle": "KeyVault.CertificateBundle", + "azure.keyvault.certificates._generated.models.CertificateCreateParameters": "KeyVault.CertificateCreateParameters", + "azure.keyvault.certificates._generated.models.CertificateImportParameters": "KeyVault.CertificateImportParameters", + "azure.keyvault.certificates._generated.models.CertificateIssuerItem": "KeyVault.CertificateIssuerItem", + "azure.keyvault.certificates._generated.models.CertificateIssuerSetParameters": "KeyVault.CertificateIssuerSetParameters", + "azure.keyvault.certificates._generated.models.CertificateIssuerUpdateParameters": "KeyVault.CertificateIssuerUpdateParameters", + "azure.keyvault.certificates._generated.models.CertificateItem": "KeyVault.CertificateItem", + "azure.keyvault.certificates._generated.models.CertificateMergeParameters": "KeyVault.CertificateMergeParameters", + "azure.keyvault.certificates._generated.models.CertificateOperation": "KeyVault.CertificateOperation", + "azure.keyvault.certificates._generated.models.CertificateOperationUpdateParameter": "KeyVault.CertificateOperationUpdateParameter", + "azure.keyvault.certificates._generated.models.CertificatePolicy": "KeyVault.CertificatePolicy", + "azure.keyvault.certificates._generated.models.CertificateRestoreParameters": "KeyVault.CertificateRestoreParameters", + "azure.keyvault.certificates._generated.models.CertificateUpdateParameters": "KeyVault.CertificateUpdateParameters", + "azure.keyvault.certificates._generated.models.Contact": "KeyVault.Contact", + "azure.keyvault.certificates._generated.models.Contacts": "KeyVault.Contacts", + "azure.keyvault.certificates._generated.models.DeletedCertificateBundle": "KeyVault.DeletedCertificateBundle", + "azure.keyvault.certificates._generated.models.DeletedCertificateItem": "KeyVault.DeletedCertificateItem", + "azure.keyvault.certificates._generated.models.IssuerAttributes": "KeyVault.IssuerAttributes", + "azure.keyvault.certificates._generated.models.IssuerBundle": "KeyVault.IssuerBundle", + "azure.keyvault.certificates._generated.models.IssuerCredentials": "KeyVault.IssuerCredentials", + "azure.keyvault.certificates._generated.models.IssuerParameters": "KeyVault.IssuerParameters", + "azure.keyvault.certificates._generated.models.KeyProperties": "KeyVault.KeyProperties", + "azure.keyvault.certificates._generated.models.KeyVaultError": "KeyVaultError", + "azure.keyvault.certificates._generated.models.KeyVaultErrorError": "KeyVaultError.error.anonymous", + "azure.keyvault.certificates._generated.models.LifetimeAction": "KeyVault.LifetimeAction", + "azure.keyvault.certificates._generated.models.OrganizationDetails": "KeyVault.OrganizationDetails", + "azure.keyvault.certificates._generated.models.SecretProperties": "KeyVault.SecretProperties", + "azure.keyvault.certificates._generated.models.SubjectAlternativeNames": "KeyVault.SubjectAlternativeNames", + "azure.keyvault.certificates._generated.models.Trigger": "KeyVault.Trigger", + "azure.keyvault.certificates._generated.models.X509CertificateProperties": "KeyVault.X509CertificateProperties", + "azure.keyvault.certificates._generated.models.DeletionRecoveryLevel": "KeyVault.DeletionRecoveryLevel", + "azure.keyvault.certificates._generated.models.JsonWebKeyType": "KeyVault.JsonWebKeyType", + "azure.keyvault.certificates._generated.models.JsonWebKeyCurveName": "KeyVault.JsonWebKeyCurveName", + "azure.keyvault.certificates._generated.models.KeyUsageType": "KeyVault.KeyUsageType", + "azure.keyvault.certificates._generated.models.CertificatePolicyAction": "KeyVault.CertificatePolicyAction", + "azure.keyvault.certificates._generated.KeyVaultClient.get_certificates": "KeyVault.getCertificates", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.get_certificates": "KeyVault.getCertificates", + "azure.keyvault.certificates._generated.KeyVaultClient.delete_certificate": "KeyVault.deleteCertificate", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.delete_certificate": "KeyVault.deleteCertificate", + "azure.keyvault.certificates._generated.KeyVaultClient.set_certificate_contacts": "KeyVault.setCertificateContacts", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.set_certificate_contacts": "KeyVault.setCertificateContacts", + "azure.keyvault.certificates._generated.KeyVaultClient.get_certificate_contacts": "KeyVault.getCertificateContacts", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.get_certificate_contacts": "KeyVault.getCertificateContacts", + "azure.keyvault.certificates._generated.KeyVaultClient.delete_certificate_contacts": "KeyVault.deleteCertificateContacts", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.delete_certificate_contacts": "KeyVault.deleteCertificateContacts", + "azure.keyvault.certificates._generated.KeyVaultClient.get_certificate_issuers": "KeyVault.getCertificateIssuers", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.get_certificate_issuers": "KeyVault.getCertificateIssuers", + "azure.keyvault.certificates._generated.KeyVaultClient.set_certificate_issuer": "KeyVault.setCertificateIssuer", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.set_certificate_issuer": "KeyVault.setCertificateIssuer", + "azure.keyvault.certificates._generated.KeyVaultClient.update_certificate_issuer": "KeyVault.updateCertificateIssuer", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.update_certificate_issuer": "KeyVault.updateCertificateIssuer", + "azure.keyvault.certificates._generated.KeyVaultClient.get_certificate_issuer": "KeyVault.getCertificateIssuer", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.get_certificate_issuer": "KeyVault.getCertificateIssuer", + "azure.keyvault.certificates._generated.KeyVaultClient.delete_certificate_issuer": "KeyVault.deleteCertificateIssuer", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.delete_certificate_issuer": "KeyVault.deleteCertificateIssuer", + "azure.keyvault.certificates._generated.KeyVaultClient.create_certificate": "KeyVault.createCertificate", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.create_certificate": "KeyVault.createCertificate", + "azure.keyvault.certificates._generated.KeyVaultClient.import_certificate": "KeyVault.importCertificate", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.import_certificate": "KeyVault.importCertificate", + "azure.keyvault.certificates._generated.KeyVaultClient.get_certificate_versions": "KeyVault.getCertificateVersions", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.get_certificate_versions": "KeyVault.getCertificateVersions", + "azure.keyvault.certificates._generated.KeyVaultClient.get_certificate_policy": "KeyVault.getCertificatePolicy", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.get_certificate_policy": "KeyVault.getCertificatePolicy", + "azure.keyvault.certificates._generated.KeyVaultClient.update_certificate_policy": "KeyVault.updateCertificatePolicy", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.update_certificate_policy": "KeyVault.updateCertificatePolicy", + "azure.keyvault.certificates._generated.KeyVaultClient.update_certificate": "KeyVault.updateCertificate", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.update_certificate": "KeyVault.updateCertificate", + "azure.keyvault.certificates._generated.KeyVaultClient.get_certificate": "KeyVault.getCertificate", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.get_certificate": "KeyVault.getCertificate", + "azure.keyvault.certificates._generated.KeyVaultClient.update_certificate_operation": "KeyVault.updateCertificateOperation", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.update_certificate_operation": "KeyVault.updateCertificateOperation", + "azure.keyvault.certificates._generated.KeyVaultClient.get_certificate_operation": "KeyVault.getCertificateOperation", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.get_certificate_operation": "KeyVault.getCertificateOperation", + "azure.keyvault.certificates._generated.KeyVaultClient.delete_certificate_operation": "KeyVault.deleteCertificateOperation", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.delete_certificate_operation": "KeyVault.deleteCertificateOperation", + "azure.keyvault.certificates._generated.KeyVaultClient.merge_certificate": "KeyVault.mergeCertificate", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.merge_certificate": "KeyVault.mergeCertificate", + "azure.keyvault.certificates._generated.KeyVaultClient.backup_certificate": "KeyVault.backupCertificate", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.backup_certificate": "KeyVault.backupCertificate", + "azure.keyvault.certificates._generated.KeyVaultClient.restore_certificate": "KeyVault.restoreCertificate", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.restore_certificate": "KeyVault.restoreCertificate", + "azure.keyvault.certificates._generated.KeyVaultClient.get_deleted_certificates": "KeyVault.getDeletedCertificates", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.get_deleted_certificates": "KeyVault.getDeletedCertificates", + "azure.keyvault.certificates._generated.KeyVaultClient.get_deleted_certificate": "KeyVault.getDeletedCertificate", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.get_deleted_certificate": "KeyVault.getDeletedCertificate", + "azure.keyvault.certificates._generated.KeyVaultClient.purge_deleted_certificate": "KeyVault.purgeDeletedCertificate", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.purge_deleted_certificate": "KeyVault.purgeDeletedCertificate", + "azure.keyvault.certificates._generated.KeyVaultClient.recover_deleted_certificate": "KeyVault.recoverDeletedCertificate", + "azure.keyvault.certificates._generated.aio.KeyVaultClient.recover_deleted_certificate": "KeyVault.recoverDeletedCertificate" + } +} \ No newline at end of file diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_client.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_client.py index d0f4f65fea02..8e2681e589fa 100644 --- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_client.py +++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_client.py @@ -100,7 +100,14 @@ def begin_create_certificate( :caption: Create a certificate :dedent: 8 """ - if not (policy.san_emails or policy.san_user_principal_names or policy.san_dns_names or policy.subject): + if not ( + policy.san_emails + or policy.san_user_principal_names + or policy.san_dns_names + or policy.san_uris + or policy.san_ip_addresses + or policy.subject + ): raise ValueError(NO_SAN_OR_SUBJECT) polling_interval = kwargs.pop("_polling_interval", None) @@ -122,29 +129,46 @@ def begin_create_certificate( pipeline_response, cert_bundle = self._client.create_certificate( certificate_name=certificate_name, parameters=parameters, - cls=lambda pipeline_response, deserialized, _: (pipeline_response, deserialized), + cls=lambda pipeline_response, deserialized, _: ( + pipeline_response, + deserialized, + ), **kwargs, ) - create_certificate_operation = CertificateOperation._from_certificate_operation_bundle(cert_bundle) + create_certificate_operation = ( + CertificateOperation._from_certificate_operation_bundle(cert_bundle) + ) - command = partial(self.get_certificate_operation, certificate_name=certificate_name, **kwargs) + command = partial( + self.get_certificate_operation, certificate_name=certificate_name, **kwargs + ) - get_certificate_command = partial(self.get_certificate, certificate_name=certificate_name, **kwargs) + get_certificate_command = partial( + self.get_certificate, certificate_name=certificate_name, **kwargs + ) create_certificate_polling = CreateCertificatePoller( pipeline_response=pipeline_response, get_certificate_command=get_certificate_command, - interval=polling_interval + interval=polling_interval, ) - def no_op(*_, **__) -> Any: # The deserialization callback is ignored based on polling implementation + def no_op( + *_, **__ + ) -> ( + Any + ): # The deserialization callback is ignored based on polling implementation pass - return LROPoller(command, create_certificate_operation, no_op, create_certificate_polling) + return LROPoller( + command, create_certificate_operation, no_op, create_certificate_polling + ) @distributed_trace - def get_certificate(self, certificate_name: str, **kwargs: Any) -> KeyVaultCertificate: + def get_certificate( + self, certificate_name: str, **kwargs: Any + ) -> KeyVaultCertificate: """Gets a certificate with its management policy attached. Requires certificates/get permission. Does not accept the version of the certificate as a parameter. To get a specific version of the @@ -172,7 +196,9 @@ def get_certificate(self, certificate_name: str, **kwargs: Any) -> KeyVaultCerti return KeyVaultCertificate._from_certificate_bundle(certificate_bundle=bundle) @distributed_trace - def get_certificate_version(self, certificate_name: str, version: str, **kwargs: Any) -> KeyVaultCertificate: + def get_certificate_version( + self, certificate_name: str, version: str, **kwargs: Any + ) -> KeyVaultCertificate: """Gets a specific version of a certificate without returning its management policy. Requires certificates/get permission. To get the latest version of the certificate, or to get the certificate's @@ -201,7 +227,9 @@ def get_certificate_version(self, certificate_name: str, version: str, **kwargs: return KeyVaultCertificate._from_certificate_bundle(certificate_bundle=bundle) @distributed_trace - def begin_delete_certificate(self, certificate_name: str, **kwargs: Any) -> LROPoller[DeletedCertificate]: + def begin_delete_certificate( + self, certificate_name: str, **kwargs: Any + ) -> LROPoller[DeletedCertificate]: """Delete all versions of a certificate. Requires certificates/delete permission. When this method returns Key Vault has begun deleting the certificate. Deletion may take several seconds in a @@ -233,16 +261,25 @@ def begin_delete_certificate(self, certificate_name: str, **kwargs: Any) -> LROP polling_interval = 2 pipeline_response, deleted_cert_bundle = self._client.delete_certificate( certificate_name=certificate_name, - cls=lambda pipeline_response, deserialized, _: (pipeline_response, deserialized), + cls=lambda pipeline_response, deserialized, _: ( + pipeline_response, + deserialized, + ), **kwargs, ) - deleted_cert = DeletedCertificate._from_deleted_certificate_bundle(deleted_cert_bundle) + deleted_cert = DeletedCertificate._from_deleted_certificate_bundle( + deleted_cert_bundle + ) polling_method = DeleteRecoverPollingMethod( # no recovery ID means soft-delete is disabled, in which case we initialize the poller as finished finished=deleted_cert.recovery_id is None, pipeline_response=pipeline_response, - command=partial(self.get_deleted_certificate, certificate_name=certificate_name, **kwargs), + command=partial( + self.get_deleted_certificate, + certificate_name=certificate_name, + **kwargs, + ), final_resource=deleted_cert, interval=polling_interval, ) @@ -250,7 +287,9 @@ def begin_delete_certificate(self, certificate_name: str, **kwargs: Any) -> LROP return KeyVaultOperationPoller(polling_method) @distributed_trace - def get_deleted_certificate(self, certificate_name: str, **kwargs: Any) -> DeletedCertificate: + def get_deleted_certificate( + self, certificate_name: str, **kwargs: Any + ) -> DeletedCertificate: """Get a deleted certificate. Possible only in a vault with soft-delete enabled. Requires certificates/get permission. Retrieves the deleted certificate information plus its attributes, such as @@ -275,7 +314,9 @@ def get_deleted_certificate(self, certificate_name: str, **kwargs: Any) -> Delet bundle = self._client.get_deleted_certificate( certificate_name=certificate_name, **kwargs ) - return DeletedCertificate._from_deleted_certificate_bundle(deleted_certificate_bundle=bundle) + return DeletedCertificate._from_deleted_certificate_bundle( + deleted_certificate_bundle=bundle + ) @distributed_trace def purge_deleted_certificate(self, certificate_name: str, **kwargs: Any) -> None: @@ -299,7 +340,9 @@ def purge_deleted_certificate(self, certificate_name: str, **kwargs: Any) -> Non ) @distributed_trace - def begin_recover_deleted_certificate(self, certificate_name: str, **kwargs: Any) -> LROPoller[KeyVaultCertificate]: + def begin_recover_deleted_certificate( + self, certificate_name: str, **kwargs: Any + ) -> LROPoller[KeyVaultCertificate]: """Recover a deleted certificate to its latest version. Possible only in a vault with soft-delete enabled. Requires certificates/recover permission. When this method returns Key Vault has begun recovering the @@ -329,19 +372,28 @@ def begin_recover_deleted_certificate(self, certificate_name: str, **kwargs: Any if polling_interval is None: polling_interval = 2 - pipeline_response, recovered_cert_bundle = self._client.recover_deleted_certificate( - certificate_name=certificate_name, - cls=lambda pipeline_response, deserialized, _: (pipeline_response, deserialized), - **kwargs, + pipeline_response, recovered_cert_bundle = ( + self._client.recover_deleted_certificate( + certificate_name=certificate_name, + cls=lambda pipeline_response, deserialized, _: ( + pipeline_response, + deserialized, + ), + **kwargs, + ) + ) + recovered_certificate = KeyVaultCertificate._from_certificate_bundle( + recovered_cert_bundle + ) + command = partial( + self.get_certificate, certificate_name=certificate_name, **kwargs ) - recovered_certificate = KeyVaultCertificate._from_certificate_bundle(recovered_cert_bundle) - command = partial(self.get_certificate, certificate_name=certificate_name, **kwargs) polling_method = DeleteRecoverPollingMethod( finished=False, pipeline_response=pipeline_response, command=command, final_resource=recovered_certificate, - interval=polling_interval + interval=polling_interval, ) return KeyVaultOperationPoller(polling_method) @@ -397,7 +449,9 @@ def import_certificate( parameters = self._models.CertificateImportParameters( base64_encoded_certificate=base64_encoded_certificate, password=password, - certificate_policy=policy._to_certificate_policy_bundle() if policy else None, + certificate_policy=( + policy._to_certificate_policy_bundle() if policy else None + ), certificate_attributes=attributes, tags=tags, preserve_cert_order=preserve_order, @@ -409,7 +463,9 @@ def import_certificate( return KeyVaultCertificate._from_certificate_bundle(certificate_bundle=bundle) @distributed_trace - def get_certificate_policy(self, certificate_name: str, **kwargs: Any) -> CertificatePolicy: + def get_certificate_policy( + self, certificate_name: str, **kwargs: Any + ) -> CertificatePolicy: """Gets the policy for a certificate. Requires certificates/get permission. Returns the specified certificate policy resources in the key vault. @@ -424,7 +480,9 @@ def get_certificate_policy(self, certificate_name: str, **kwargs: Any) -> Certif bundle = self._client.get_certificate_policy( certificate_name=certificate_name, **kwargs ) - return CertificatePolicy._from_certificate_policy_bundle(certificate_policy_bundle=bundle) + return CertificatePolicy._from_certificate_policy_bundle( + certificate_policy_bundle=bundle + ) @distributed_trace def update_certificate_policy( @@ -446,9 +504,11 @@ def update_certificate_policy( bundle = self._client.update_certificate_policy( certificate_name=certificate_name, certificate_policy=policy._to_certificate_policy_bundle(), - **kwargs + **kwargs, + ) + return CertificatePolicy._from_certificate_policy_bundle( + certificate_policy_bundle=bundle ) - return CertificatePolicy._from_certificate_policy_bundle(certificate_policy_bundle=bundle) @distributed_trace def update_certificate_properties( @@ -496,7 +556,7 @@ def update_certificate_properties( certificate_name=certificate_name, certificate_version=version or "", parameters=parameters, - **kwargs + **kwargs, ) return KeyVaultCertificate._from_certificate_bundle(certificate_bundle=bundle) @@ -531,7 +591,9 @@ def backup_certificate(self, certificate_name: str, **kwargs: Any) -> bytes: return backup_result.value @distributed_trace - def restore_certificate_backup(self, backup: bytes, **kwargs: Any) -> KeyVaultCertificate: + def restore_certificate_backup( + self, backup: bytes, **kwargs: Any + ) -> KeyVaultCertificate: """Restore a certificate backup to the vault. Requires certificates/restore permission. This restores all versions of the certificate, with its name, attributes, and access control policies. If the @@ -554,8 +616,10 @@ def restore_certificate_backup(self, backup: bytes, **kwargs: Any) -> KeyVaultCe :dedent: 8 """ bundle = self._client.restore_certificate( - parameters=self._models.CertificateRestoreParameters(certificate_bundle_backup=backup), - **kwargs + parameters=self._models.CertificateRestoreParameters( + certificate_bundle_backup=backup + ), + **kwargs, ) return KeyVaultCertificate._from_certificate_bundle(certificate_bundle=bundle) @@ -599,9 +663,12 @@ def list_deleted_certificates( return self._client.get_deleted_certificates( maxresults=max_page_size, cls=lambda objs: [ - DeletedCertificate._from_deleted_certificate_item(deleted_certificate_item=x) for x in objs + DeletedCertificate._from_deleted_certificate_item( + deleted_certificate_item=x + ) + for x in objs ], - **kwargs + **kwargs, ) @distributed_trace @@ -642,8 +709,11 @@ def list_properties_of_certificates( return self._client.get_certificates( maxresults=max_page_size, - cls=lambda objs: [CertificateProperties._from_certificate_item(certificate_item=x) for x in objs], - **kwargs + cls=lambda objs: [ + CertificateProperties._from_certificate_item(certificate_item=x) + for x in objs + ], + **kwargs, ) @distributed_trace @@ -673,12 +743,17 @@ def list_properties_of_certificate_versions( return self._client.get_certificate_versions( certificate_name=certificate_name, maxresults=max_page_size, - cls=lambda objs: [CertificateProperties._from_certificate_item(certificate_item=x) for x in objs], - **kwargs + cls=lambda objs: [ + CertificateProperties._from_certificate_item(certificate_item=x) + for x in objs + ], + **kwargs, ) @distributed_trace - def set_contacts(self, contacts: "List[CertificateContact]", **kwargs: Any) -> "List[CertificateContact]": + def set_contacts( + self, contacts: "List[CertificateContact]", **kwargs: Any + ) -> "List[CertificateContact]": """Sets the certificate contacts for the key vault. Requires certificates/managecontacts permission. :param contacts: The contact list for the vault certificates. @@ -698,11 +773,14 @@ def set_contacts(self, contacts: "List[CertificateContact]", **kwargs: Any) -> " :dedent: 8 """ new_contacts = self._client.set_certificate_contacts( - contacts=self._models.Contacts(contact_list=[c._to_certificate_contacts_item() for c in contacts]), - **kwargs + contacts=self._models.Contacts( + contact_list=[c._to_certificate_contacts_item() for c in contacts] + ), + **kwargs, ) return [ - CertificateContact._from_certificate_contacts_item(contact_item=item) for item in new_contacts.contact_list + CertificateContact._from_certificate_contacts_item(contact_item=item) + for item in new_contacts.contact_list ] @distributed_trace @@ -723,7 +801,10 @@ def get_contacts(self, **kwargs: Any) -> "List[CertificateContact]": :dedent: 8 """ contacts = self._client.get_certificate_contacts(**kwargs) - return [CertificateContact._from_certificate_contacts_item(contact_item=item) for item in contacts.contact_list] + return [ + CertificateContact._from_certificate_contacts_item(contact_item=item) + for item in contacts.contact_list + ] @distributed_trace def delete_contacts(self, **kwargs: Any) -> "List[CertificateContact]": @@ -743,10 +824,15 @@ def delete_contacts(self, **kwargs: Any) -> "List[CertificateContact]": :dedent: 8 """ contacts = self._client.delete_certificate_contacts(**kwargs) - return [CertificateContact._from_certificate_contacts_item(contact_item=item) for item in contacts.contact_list] + return [ + CertificateContact._from_certificate_contacts_item(contact_item=item) + for item in contacts.contact_list + ] @distributed_trace - def get_certificate_operation(self, certificate_name: str, **kwargs: Any) -> CertificateOperation: + def get_certificate_operation( + self, certificate_name: str, **kwargs: Any + ) -> CertificateOperation: """Gets the creation operation of a certificate. Requires the certificates/get permission. :param str certificate_name: The name of the certificate. @@ -761,10 +847,14 @@ def get_certificate_operation(self, certificate_name: str, **kwargs: Any) -> Cer bundle = self._client.get_certificate_operation( certificate_name=certificate_name, **kwargs ) - return CertificateOperation._from_certificate_operation_bundle(certificate_operation_bundle=bundle) + return CertificateOperation._from_certificate_operation_bundle( + certificate_operation_bundle=bundle + ) @distributed_trace - def delete_certificate_operation(self, certificate_name: str, **kwargs: Any) -> CertificateOperation: + def delete_certificate_operation( + self, certificate_name: str, **kwargs: Any + ) -> CertificateOperation: """Deletes and stops the creation operation for a specific certificate. Requires the certificates/update permission. @@ -779,10 +869,14 @@ def delete_certificate_operation(self, certificate_name: str, **kwargs: Any) -> bundle = self._client.delete_certificate_operation( certificate_name=certificate_name, **kwargs ) - return CertificateOperation._from_certificate_operation_bundle(certificate_operation_bundle=bundle) + return CertificateOperation._from_certificate_operation_bundle( + certificate_operation_bundle=bundle + ) @distributed_trace - def cancel_certificate_operation(self, certificate_name: str, **kwargs: Any) -> CertificateOperation: + def cancel_certificate_operation( + self, certificate_name: str, **kwargs: Any + ) -> CertificateOperation: """Cancels an in-progress certificate operation. Requires the certificates/update permission. :param str certificate_name: The name of the certificate. @@ -794,10 +888,14 @@ def cancel_certificate_operation(self, certificate_name: str, **kwargs: Any) -> """ bundle = self._client.update_certificate_operation( certificate_name=certificate_name, - certificate_operation=self._models.CertificateOperationUpdateParameter(cancellation_requested=True), - **kwargs + certificate_operation=self._models.CertificateOperationUpdateParameter( + cancellation_requested=True + ), + **kwargs, + ) + return CertificateOperation._from_certificate_operation_bundle( + certificate_operation_bundle=bundle ) - return CertificateOperation._from_certificate_operation_bundle(certificate_operation_bundle=bundle) @distributed_trace def merge_certificate( @@ -837,7 +935,9 @@ def merge_certificate( attributes = None parameters = self._models.CertificateMergeParameters( - x509_certificates=x509_certificates, certificate_attributes=attributes, tags=tags + x509_certificates=x509_certificates, + certificate_attributes=attributes, + tags=tags, ) bundle = self._client.merge_certificate( @@ -911,7 +1011,9 @@ def create_issuer( """ if account_id or password: - issuer_credentials = self._models.IssuerCredentials(account_id=account_id, password=password) + issuer_credentials = self._models.IssuerCredentials( + account_id=account_id, password=password + ) else: issuer_credentials = None if admin_contacts: @@ -927,7 +1029,9 @@ def create_issuer( else: admin_details = None if organization_id or admin_details: - organization_details = self._models.OrganizationDetails(id=organization_id, admin_details=admin_details) + organization_details = self._models.OrganizationDetails( + id=organization_id, admin_details=admin_details + ) else: organization_details = None if enabled is not None: @@ -979,7 +1083,9 @@ def update_issuer( """ if account_id or password: - issuer_credentials = self._models.IssuerCredentials(account_id=account_id, password=password) + issuer_credentials = self._models.IssuerCredentials( + account_id=account_id, password=password + ) else: issuer_credentials = None if admin_contacts: @@ -995,7 +1101,9 @@ def update_issuer( else: admin_details = None if organization_id or admin_details: - organization_details = self._models.OrganizationDetails(id=organization_id, admin_details=admin_details) + organization_details = self._models.OrganizationDetails( + id=organization_id, admin_details=admin_details + ) else: organization_details = None if enabled is not None: @@ -1063,8 +1171,10 @@ def list_properties_of_issuers(self, **kwargs: Any) -> ItemPaged[IssuerPropertie max_page_size = kwargs.pop("max_page_size", None) return self._client.get_certificate_issuers( maxresults=max_page_size, - cls=lambda objs: [IssuerProperties._from_issuer_item(issuer_item=x) for x in objs], - **kwargs + cls=lambda objs: [ + IssuerProperties._from_issuer_item(issuer_item=x) for x in objs + ], + **kwargs, ) def __enter__(self) -> "CertificateClient": diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_utils/model_base.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_utils/model_base.py index 49d5c7259389..b52fc2ccf130 100644 --- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_utils/model_base.py +++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_utils/model_base.py @@ -130,7 +130,13 @@ def _is_readonly(p): class SdkJSONEncoder(JSONEncoder): """A JSON encoder that's capable of serializing datetime objects and bytes.""" - def __init__(self, *args, exclude_readonly: bool = False, format: typing.Optional[str] = None, **kwargs): + def __init__( + self, + *args, + exclude_readonly: bool = False, + format: typing.Optional[str] = None, + **kwargs, + ): super().__init__(*args, **kwargs) self.exclude_readonly = exclude_readonly self.format = format @@ -138,7 +144,11 @@ def __init__(self, *args, exclude_readonly: bool = False, format: typing.Optiona def default(self, o): # pylint: disable=too-many-return-statements if _is_model(o): if self.exclude_readonly: - readonly_props = [p._rest_name for p in o._attr_to_rest_field.values() if _is_readonly(p)] + readonly_props = [ + p._rest_name + for p in o._attr_to_rest_field.values() + if _is_readonly(p) + ] return {k: v for k, v in o.items() if k not in readonly_props} return dict(o.items()) try: @@ -164,7 +174,9 @@ def default(self, o): # pylint: disable=too-many-return-statements return super(SdkJSONEncoder, self).default(o) -_VALID_DATE = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" + r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?") +_VALID_DATE = re.compile( + r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" + r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?" +) _VALID_RFC7231 = re.compile( r"(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s\d{2}\s" r"(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s\d{4}\s\d{2}:\d{2}:\d{2}\sGMT" @@ -221,7 +233,9 @@ def _deserialize_datetime_rfc7231(attr: typing.Union[str, datetime]) -> datetime return email.utils.parsedate_to_datetime(attr) -def _deserialize_datetime_unix_timestamp(attr: typing.Union[float, datetime]) -> datetime: +def _deserialize_datetime_unix_timestamp( + attr: typing.Union[float, datetime] +) -> datetime: """Deserialize unix timestamp into Datetime object. :param str attr: response string to be deserialized. @@ -331,9 +345,19 @@ def _get_type_alias_type(module_name: str, alias_name: str): def _get_model(module_name: str, model_name: str): - models = {k: v for k, v in sys.modules[module_name].__dict__.items() if isinstance(v, type)} + models = { + k: v + for k, v in sys.modules[module_name].__dict__.items() + if isinstance(v, type) + } module_end = module_name.rsplit(".", 1)[0] - models.update({k: v for k, v in sys.modules[module_end].__dict__.items() if isinstance(v, type)}) + models.update( + { + k: v + for k, v in sys.modules[module_end].__dict__.items() + if isinstance(v, type) + } + ) if isinstance(model_name, str): model_name = model_name.split(".")[-1] if model_name not in models: @@ -410,7 +434,9 @@ def pop(self, key: str) -> typing.Any: ... # pylint: disable=arguments-differ def pop(self, key: str, default: _T) -> _T: ... # pylint: disable=signature-differs @typing.overload - def pop(self, key: str, default: typing.Any) -> typing.Any: ... # pylint: disable=signature-differs + def pop( + self, key: str, default: typing.Any + ) -> typing.Any: ... # pylint: disable=signature-differs def pop(self, key: str, default: typing.Any = _UNSET) -> typing.Any: """ @@ -440,7 +466,9 @@ def clear(self) -> None: """ self._data.clear() - def update(self, *args: typing.Any, **kwargs: typing.Any) -> None: # pylint: disable=arguments-differ + def update( + self, *args: typing.Any, **kwargs: typing.Any + ) -> None: # pylint: disable=arguments-differ """ Updates D from mapping/iterable E and F. :param any args: Either a mapping object or an iterable of key-value pairs. @@ -451,7 +479,9 @@ def update(self, *args: typing.Any, **kwargs: typing.Any) -> None: # pylint: di def setdefault(self, key: str, default: None = None) -> None: ... @typing.overload - def setdefault(self, key: str, default: typing.Any) -> typing.Any: ... # pylint: disable=signature-differs + def setdefault( + self, key: str, default: typing.Any + ) -> typing.Any: ... # pylint: disable=signature-differs def setdefault(self, key: str, default: typing.Any = _UNSET) -> typing.Any: """ @@ -480,7 +510,9 @@ def _is_model(obj: typing.Any) -> bool: return getattr(obj, "_is_model", False) -def _serialize(o, format: typing.Optional[str] = None): # pylint: disable=too-many-return-statements +def _serialize( + o, format: typing.Optional[str] = None +): # pylint: disable=too-many-return-statements if isinstance(o, list): return [_serialize(x, format) for x in o] if isinstance(o, dict): @@ -517,7 +549,9 @@ def _get_rest_field( attr_to_rest_field: typing.Dict[str, "_RestField"], rest_name: str ) -> typing.Optional["_RestField"]: try: - return next(rf for rf in attr_to_rest_field.values() if rf._rest_name == rest_name) + return next( + rf for rf in attr_to_rest_field.values() if rf._rest_name == rest_name + ) except StopIteration: return None @@ -543,7 +577,9 @@ class Model(_MyMutableMapping): def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None: class_name = self.__class__.__name__ if len(args) > 1: - raise TypeError(f"{class_name}.__init__() takes 2 positional arguments but {len(args) + 1} were given") + raise TypeError( + f"{class_name}.__init__() takes 2 positional arguments but {len(args) + 1} were given" + ) dict_to_pass = { rest_field._rest_name: rest_field._default for rest_field in self._attr_to_rest_field.values() @@ -562,9 +598,14 @@ def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None: xml_name = "{" + xml_ns + "}" + xml_name # attribute - if prop_meta.get("attribute", False) and args[0].get(xml_name) is not None: + if ( + prop_meta.get("attribute", False) + and args[0].get(xml_name) is not None + ): existed_attr_keys.append(xml_name) - dict_to_pass[rf._rest_name] = _deserialize(rf._type, args[0].get(xml_name)) + dict_to_pass[rf._rest_name] = _deserialize( + rf._type, args[0].get(xml_name) + ) continue # unwrapped element is array @@ -584,7 +625,9 @@ def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None: # text element is primitive type if prop_meta.get("text", False): if args[0].text is not None: - dict_to_pass[rf._rest_name] = _deserialize(rf._type, args[0].text) + dict_to_pass[rf._rest_name] = _deserialize( + rf._type, args[0].text + ) continue # wrapped element could be normal property or array, it should only have one element @@ -599,16 +642,25 @@ def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None: dict_to_pass[e.tag] = _convert_element(e) else: dict_to_pass.update( - {k: _create_value(_get_rest_field(self._attr_to_rest_field, k), v) for k, v in args[0].items()} + { + k: _create_value( + _get_rest_field(self._attr_to_rest_field, k), v + ) + for k, v in args[0].items() + } ) else: non_attr_kwargs = [k for k in kwargs if k not in self._attr_to_rest_field] if non_attr_kwargs: # actual type errors only throw the first wrong keyword arg they see, so following that. - raise TypeError(f"{class_name}.__init__() got an unexpected keyword argument '{non_attr_kwargs[0]}'") + raise TypeError( + f"{class_name}.__init__() got an unexpected keyword argument '{non_attr_kwargs[0]}'" + ) dict_to_pass.update( { - self._attr_to_rest_field[k]._rest_name: _create_value(self._attr_to_rest_field[k], v) + self._attr_to_rest_field[k]._rest_name: _create_value( + self._attr_to_rest_field[k], v + ) for k, v in kwargs.items() if v is not None } @@ -623,9 +675,14 @@ def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> Self: # we know the last nine classes in mro are going to be 'Model', '_MyMutableMapping', 'MutableMapping', # 'Mapping', 'Collection', 'Sized', 'Iterable', 'Container' and 'object' mros = cls.__mro__[:-9][::-1] # ignore parents, and reverse the mro order - attr_to_rest_field: typing.Dict[str, _RestField] = { # map attribute name to rest_field property - k: v for mro_class in mros for k, v in mro_class.__dict__.items() if k[0] != "_" and hasattr(v, "_type") - } + attr_to_rest_field: typing.Dict[str, _RestField] = ( + { # map attribute name to rest_field property + k: v + for mro_class in mros + for k, v in mro_class.__dict__.items() + if k[0] != "_" and hasattr(v, "_type") + } + ) annotations = { k: v for mro_class in mros @@ -635,10 +692,14 @@ def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> Self: for attr, rf in attr_to_rest_field.items(): rf._module = cls.__module__ if not rf._type: - rf._type = rf._get_deserialize_callable_from_annotation(annotations.get(attr, None)) + rf._type = rf._get_deserialize_callable_from_annotation( + annotations.get(attr, None) + ) if not rf._rest_name_input: rf._rest_name_input = attr - cls._attr_to_rest_field: typing.Dict[str, _RestField] = dict(attr_to_rest_field.items()) + cls._attr_to_rest_field: typing.Dict[str, _RestField] = dict( + attr_to_rest_field.items() + ) cls._calculated.add(f"{cls.__module__}.{cls.__qualname__}") return super().__new__(cls) @@ -651,7 +712,11 @@ def __init_subclass__(cls, discriminator: typing.Optional[str] = None) -> None: @classmethod def _get_discriminator(cls, exist_discriminators) -> typing.Optional["_RestField"]: for v in cls.__dict__.values(): - if isinstance(v, _RestField) and v._is_discriminator and v._rest_name not in exist_discriminators: + if ( + isinstance(v, _RestField) + and v._is_discriminator + and v._rest_name not in exist_discriminators + ): return v return None @@ -677,10 +742,14 @@ def _deserialize(cls, data, exist_discriminators): discriminator_value = data.find(xml_name).text # pyright: ignore else: discriminator_value = data.get(discriminator._rest_name) - mapped_cls = cls.__mapping__.get(discriminator_value, cls) # pyright: ignore # pylint: disable=no-member + mapped_cls = cls.__mapping__.get( + discriminator_value, cls + ) # pyright: ignore # pylint: disable=no-member return mapped_cls._deserialize(data, exist_discriminators) - def as_dict(self, *, exclude_readonly: bool = False) -> typing.Dict[str, typing.Any]: + def as_dict( + self, *, exclude_readonly: bool = False + ) -> typing.Dict[str, typing.Any]: """Return a dict that can be turned into json using json.dump. :keyword bool exclude_readonly: Whether to remove the readonly properties. @@ -691,7 +760,11 @@ def as_dict(self, *, exclude_readonly: bool = False) -> typing.Dict[str, typing. result = {} readonly_props = [] if exclude_readonly: - readonly_props = [p._rest_name for p in self._attr_to_rest_field.values() if _is_readonly(p)] + readonly_props = [ + p._rest_name + for p in self._attr_to_rest_field.values() + if _is_readonly(p) + ] for k, v in self.items(): if exclude_readonly and k in readonly_props: # pyright: ignore continue @@ -702,7 +775,11 @@ def as_dict(self, *, exclude_readonly: bool = False) -> typing.Dict[str, typing. )._is_multipart_file_input except StopIteration: pass - result[k] = v if is_multipart_file_input else Model._as_dict_value(v, exclude_readonly=exclude_readonly) + result[k] = ( + v + if is_multipart_file_input + else Model._as_dict_value(v, exclude_readonly=exclude_readonly) + ) return result @staticmethod @@ -710,10 +787,17 @@ def _as_dict_value(v: typing.Any, exclude_readonly: bool = False) -> typing.Any: if v is None or isinstance(v, _Null): return None if isinstance(v, (list, tuple, set)): - return type(v)(Model._as_dict_value(x, exclude_readonly=exclude_readonly) for x in v) + return type(v)( + Model._as_dict_value(x, exclude_readonly=exclude_readonly) for x in v + ) if isinstance(v, dict): - return {dk: Model._as_dict_value(dv, exclude_readonly=exclude_readonly) for dk, dv in v.items()} - return v.as_dict(exclude_readonly=exclude_readonly) if hasattr(v, "as_dict") else v + return { + dk: Model._as_dict_value(dv, exclude_readonly=exclude_readonly) + for dk, dv in v.items() + } + return ( + v.as_dict(exclude_readonly=exclude_readonly) if hasattr(v, "as_dict") else v + ) def _deserialize_model(model_deserializer: typing.Optional[typing.Callable], obj): @@ -722,7 +806,9 @@ def _deserialize_model(model_deserializer: typing.Optional[typing.Callable], obj return _deserialize(model_deserializer, obj) -def _deserialize_with_optional(if_obj_deserializer: typing.Optional[typing.Callable], obj): +def _deserialize_with_optional( + if_obj_deserializer: typing.Optional[typing.Callable], obj +): if obj is None: return obj return _deserialize_with_callable(if_obj_deserializer, obj) @@ -756,7 +842,10 @@ def _deserialize_multiple_sequence( ): if obj is None: return obj - return type(obj)(_deserialize(deserializer, entry, module) for entry, deserializer in zip(obj, entry_deserializers)) + return type(obj)( + _deserialize(deserializer, entry, module) + for entry, deserializer in zip(obj, entry_deserializers) + ) def _deserialize_sequence( @@ -774,7 +863,8 @@ def _deserialize_sequence( def _sorted_annotations(types: typing.List[typing.Any]) -> typing.List[typing.Any]: return sorted( types, - key=lambda x: hasattr(x, "__name__") and x.__name__.lower() in ("str", "float", "int", "bool"), + key=lambda x: hasattr(x, "__name__") + and x.__name__.lower() in ("str", "float", "int", "bool"), ) @@ -821,14 +911,22 @@ def _get_deserialize_callable_from_annotation( # pylint: disable=too-many-retur if any(a for a in annotation.__args__ if a == type(None)): # pyright: ignore if len(annotation.__args__) <= 2: # pyright: ignore if_obj_deserializer = _get_deserialize_callable_from_annotation( - next(a for a in annotation.__args__ if a != type(None)), module, rf # pyright: ignore + next(a for a in annotation.__args__ if a != type(None)), + module, + rf, # pyright: ignore ) - return functools.partial(_deserialize_with_optional, if_obj_deserializer) + return functools.partial( + _deserialize_with_optional, if_obj_deserializer + ) # the type is Optional[Union[...]], we need to remove the None type from the Union annotation_copy = copy.copy(annotation) - annotation_copy.__args__ = [a for a in annotation_copy.__args__ if a != type(None)] # pyright: ignore - return _get_deserialize_callable_from_annotation(annotation_copy, module, rf) + annotation_copy.__args__ = [ + a for a in annotation_copy.__args__ if a != type(None) + ] # pyright: ignore + return _get_deserialize_callable_from_annotation( + annotation_copy, module, rf + ) except AttributeError: pass @@ -843,7 +941,12 @@ def _get_deserialize_callable_from_annotation( # pylint: disable=too-many-retur return functools.partial(_deserialize_with_union, deserializers) try: - if annotation._name == "Dict": # pyright: ignore + annotation_name = ( + annotation.__name__ + if hasattr(annotation, "__name__") + else annotation._name # pyright: ignore + ) + if annotation_name.lower() == "dict": value_deserializer = _get_deserialize_callable_from_annotation( annotation.__args__[1], module, rf # pyright: ignore ) @@ -853,16 +956,15 @@ def _get_deserialize_callable_from_annotation( # pylint: disable=too-many-retur value_deserializer, module, ) - except (AttributeError, IndexError): - pass - try: - if annotation._name in ["List", "Set", "Tuple", "Sequence"]: # pyright: ignore + if annotation_name.lower() in ["list", "set", "tuple", "sequence"]: if len(annotation.__args__) > 1: # pyright: ignore entry_deserializers = [ _get_deserialize_callable_from_annotation(dt, module, rf) for dt in annotation.__args__ # pyright: ignore ] - return functools.partial(_deserialize_multiple_sequence, entry_deserializers, module) + return functools.partial( + _deserialize_multiple_sequence, entry_deserializers, module + ) deserializer = _get_deserialize_callable_from_annotation( annotation.__args__[0], module, rf # pyright: ignore ) @@ -917,7 +1019,9 @@ def _deserialize_with_callable( return value if isinstance(deserializer, type) and issubclass(deserializer, Model): return deserializer._deserialize(value, []) - return typing.cast(typing.Callable[[typing.Any], typing.Any], deserializer)(value) + return typing.cast(typing.Callable[[typing.Any], typing.Any], deserializer)( + value + ) except Exception as e: raise DeserializationError() from e @@ -934,7 +1038,9 @@ def _deserialize( if rf is None and format: rf = _RestField(format=format) if not isinstance(deserializer, functools.partial): - deserializer = _get_deserialize_callable_from_annotation(deserializer, module, rf) + deserializer = _get_deserialize_callable_from_annotation( + deserializer, module, rf + ) return _deserialize_with_callable(deserializer, value) @@ -949,7 +1055,8 @@ def _failsafe_deserialize( return _deserialize(deserializer, value, module, rf, format) except DeserializationError: _LOGGER.warning( - "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True + "Ran into a deserialization error. Ignoring since this is failsafe deserialization", + exc_info=True, ) return None @@ -962,7 +1069,8 @@ def _failsafe_deserialize_xml( return _deserialize_xml(deserializer, value) except DeserializationError: _LOGGER.warning( - "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True + "Ran into a deserialization error. Ignoring since this is failsafe deserialization", + exc_info=True, ) return None @@ -972,7 +1080,9 @@ def __init__( self, *, name: typing.Optional[str] = None, - type: typing.Optional[typing.Callable] = None, # pylint: disable=redefined-builtin + type: typing.Optional[ + typing.Callable + ] = None, # pylint: disable=redefined-builtin is_discriminator: bool = False, visibility: typing.Optional[typing.List[str]] = None, default: typing.Any = _UNSET, @@ -1060,7 +1170,9 @@ def rest_discriminator( visibility: typing.Optional[typing.List[str]] = None, xml: typing.Optional[typing.Dict[str, typing.Any]] = None, ) -> typing.Any: - return _RestField(name=name, type=type, is_discriminator=True, visibility=visibility, xml=xml) + return _RestField( + name=name, type=type, is_discriminator=True, visibility=visibility, xml=xml + ) def serialize_xml(model: Model, exclude_readonly: bool = False) -> str: @@ -1093,7 +1205,9 @@ def _get_element( readonly_props = [] if exclude_readonly: - readonly_props = [p._rest_name for p in o._attr_to_rest_field.values() if _is_readonly(p)] + readonly_props = [ + p._rest_name for p in o._attr_to_rest_field.values() if _is_readonly(p) + ] for k, v in o.items(): # do not serialize readonly properties @@ -1124,13 +1238,19 @@ def _get_element( elif prop_meta.get("attribute", False): xml_name = prop_meta.get("name", k) if prop_meta.get("ns"): - ET.register_namespace(prop_meta.get("prefix"), prop_meta.get("ns")) # pyright: ignore - xml_name = "{" + prop_meta.get("ns") + "}" + xml_name # pyright: ignore + ET.register_namespace( + prop_meta.get("prefix"), prop_meta.get("ns") + ) # pyright: ignore + xml_name = ( + "{" + prop_meta.get("ns") + "}" + xml_name + ) # pyright: ignore # attribute should be primitive type wrapped_element.set(xml_name, _get_primitive_type_value(v)) else: # other wrapped prop element - wrapped_element.append(_get_wrapped_element(v, exclude_readonly, prop_meta)) + wrapped_element.append( + _get_wrapped_element(v, exclude_readonly, prop_meta) + ) return wrapped_element if isinstance(o, list): return [_get_element(x, exclude_readonly, parent_meta) for x in o] # type: ignore @@ -1171,7 +1291,9 @@ def _get_wrapped_element( meta: typing.Optional[typing.Dict[str, typing.Any]], ) -> ET.Element: wrapped_element = _create_xml_element( - meta.get("name") if meta else None, meta.get("prefix") if meta else None, meta.get("ns") if meta else None + meta.get("name") if meta else None, + meta.get("prefix") if meta else None, + meta.get("ns") if meta else None, ) if isinstance(v, (dict, list)): wrapped_element.extend(_get_element(v, exclude_readonly, meta)) @@ -1217,7 +1339,10 @@ def _convert_element(e: ET.Element): if isinstance(dict_result[child.tag], list): dict_result[child.tag].append(_convert_element(child)) else: - dict_result[child.tag] = [dict_result[child.tag], _convert_element(child)] + dict_result[child.tag] = [ + dict_result[child.tag], + _convert_element(child), + ] else: dict_result[child.tag] = _convert_element(child) dict_result.update(e.attrib) diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_version.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_version.py index 0d777283b3a2..2e2a864184cb 100644 --- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_version.py +++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "4.9.0b1" +VERSION = "4.11.0" diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_models.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_models.py index db216476930a..079afb7799ab 100644 --- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_models.py +++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_models.py @@ -9,7 +9,7 @@ # pylint: disable=useless-super-delegation import datetime -from typing import Any, Dict, List, Mapping, Optional, TYPE_CHECKING, Union, overload +from typing import Any, Mapping, Optional, TYPE_CHECKING, Union, overload from .._utils.model_base import Model as _Model, rest_field @@ -61,13 +61,21 @@ class AdministratorDetails(_Model): :vartype phone: str """ - first_name: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + first_name: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """First name.""" - last_name: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + last_name: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Last name.""" - email_address: Optional[str] = rest_field(name="email", visibility=["read", "create", "update", "delete", "query"]) + email_address: Optional[str] = rest_field( + name="email", visibility=["read", "create", "update", "delete", "query"] + ) """Email address.""" - phone: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + phone: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Phone number.""" @overload @@ -128,21 +136,33 @@ class CertificateAttributes(_Model): ~azure.keyvault.certificates._generated.models.DeletionRecoveryLevel """ - enabled: Optional[bool] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + enabled: Optional[bool] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Determines whether the object is enabled.""" not_before: Optional[datetime.datetime] = rest_field( - name="nbf", visibility=["read", "create", "update", "delete", "query"], format="unix-timestamp" + name="nbf", + visibility=["read", "create", "update", "delete", "query"], + format="unix-timestamp", ) """Not before date in UTC.""" expires: Optional[datetime.datetime] = rest_field( - name="exp", visibility=["read", "create", "update", "delete", "query"], format="unix-timestamp" + name="exp", + visibility=["read", "create", "update", "delete", "query"], + format="unix-timestamp", ) """Expiry date in UTC.""" - created: Optional[datetime.datetime] = rest_field(visibility=["read"], format="unix-timestamp") + created: Optional[datetime.datetime] = rest_field( + visibility=["read"], format="unix-timestamp" + ) """Creation time in UTC.""" - updated: Optional[datetime.datetime] = rest_field(visibility=["read"], format="unix-timestamp") + updated: Optional[datetime.datetime] = rest_field( + visibility=["read"], format="unix-timestamp" + ) """Last updated time in UTC.""" - recoverable_days: Optional[int] = rest_field(name="recoverableDays", visibility=["read"]) + recoverable_days: Optional[int] = rest_field( + name="recoverableDays", visibility=["read"] + ) """softDelete data retention days. Value should be >=7 and <=90 when softDelete enabled, otherwise 0.""" recovery_level: Optional[Union[str, "_models.DeletionRecoveryLevel"]] = rest_field( @@ -191,7 +211,7 @@ class CertificateBundle(_Model): :ivar cer: CER contents of x509 certificate. :vartype cer: bytes :ivar content_type: The content type of the secret. eg. 'application/x-pem-file' or - 'application/x-pkcs12',. + 'application/x-pkcs12'. :vartype content_type: str :ivar attributes: The certificate attributes. :vartype attributes: ~azure.keyvault.certificates._generated.models.CertificateAttributes @@ -208,24 +228,31 @@ class CertificateBundle(_Model): """The key id.""" sid: Optional[str] = rest_field(visibility=["read"]) """The secret id.""" - x509_thumbprint: Optional[bytes] = rest_field(name="x5t", visibility=["read"], format="base64url") + x509_thumbprint: Optional[bytes] = rest_field( + name="x5t", visibility=["read"], format="base64url" + ) """Thumbprint of the certificate.""" policy: Optional["_models.CertificatePolicy"] = rest_field(visibility=["read"]) """The management policy.""" - cer: Optional[bytes] = rest_field(visibility=["read", "create", "update", "delete", "query"], format="base64") + cer: Optional[bytes] = rest_field( + visibility=["read", "create", "update", "delete", "query"], format="base64" + ) """CER contents of x509 certificate.""" content_type: Optional[str] = rest_field( name="contentType", visibility=["read", "create", "update", "delete", "query"] ) - """The content type of the secret. eg. 'application/x-pem-file' or 'application/x-pkcs12',.""" + """The content type of the secret. eg. 'application/x-pem-file' or 'application/x-pkcs12'.""" attributes: Optional["_models.CertificateAttributes"] = rest_field( visibility=["read", "create", "update", "delete", "query"] ) """The certificate attributes.""" - tags: Optional[Dict[str, str]] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + tags: Optional[dict[str, str]] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Application specific metadata in the form of key-value pairs.""" preserve_cert_order: Optional[bool] = rest_field( - name="preserveCertOrder", visibility=["read", "create", "update", "delete", "query"] + name="preserveCertOrder", + visibility=["read", "create", "update", "delete", "query"], ) """Specifies whether the certificate chain preserves its original order. The default value is false, which sets the leaf certificate at index 0.""" @@ -237,7 +264,7 @@ def __init__( cer: Optional[bytes] = None, content_type: Optional[str] = None, attributes: Optional["_models.CertificateAttributes"] = None, - tags: Optional[Dict[str, str]] = None, + tags: Optional[dict[str, str]] = None, preserve_cert_order: Optional[bool] = None, ) -> None: ... @@ -275,10 +302,13 @@ class CertificateCreateParameters(_Model): name="attributes", visibility=["read", "create", "update", "delete", "query"] ) """The attributes of the certificate (optional).""" - tags: Optional[Dict[str, str]] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + tags: Optional[dict[str, str]] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Application specific metadata in the form of key-value pairs.""" preserve_cert_order: Optional[bool] = rest_field( - name="preserveCertOrder", visibility=["read", "create", "update", "delete", "query"] + name="preserveCertOrder", + visibility=["read", "create", "update", "delete", "query"], ) """Specifies whether the certificate chain preserves its original order. The default value is false, which sets the leaf certificate at index 0.""" @@ -289,7 +319,7 @@ def __init__( *, certificate_policy: Optional["_models.CertificatePolicy"] = None, certificate_attributes: Optional["_models.CertificateAttributes"] = None, - tags: Optional[Dict[str, str]] = None, + tags: Optional[dict[str, str]] = None, preserve_cert_order: Optional[bool] = None, ) -> None: ... @@ -330,7 +360,9 @@ class CertificateImportParameters(_Model): ) """Base64 encoded representation of the certificate object to import. This certificate needs to contain the private key. Required.""" - password: Optional[str] = rest_field(name="pwd", visibility=["read", "create", "update", "delete", "query"]) + password: Optional[str] = rest_field( + name="pwd", visibility=["read", "create", "update", "delete", "query"] + ) """If the private key in base64EncodedCertificate is encrypted, the password used for encryption.""" certificate_policy: Optional["_models.CertificatePolicy"] = rest_field( name="policy", visibility=["read", "create", "update", "delete", "query"] @@ -340,10 +372,13 @@ class CertificateImportParameters(_Model): name="attributes", visibility=["read", "create", "update", "delete", "query"] ) """The attributes of the certificate (optional).""" - tags: Optional[Dict[str, str]] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + tags: Optional[dict[str, str]] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Application specific metadata in the form of key-value pairs.""" preserve_cert_order: Optional[bool] = rest_field( - name="preserveCertOrder", visibility=["read", "create", "update", "delete", "query"] + name="preserveCertOrder", + visibility=["read", "create", "update", "delete", "query"], ) """Specifies whether the certificate chain preserves its original order. The default value is false, which sets the leaf certificate at index 0.""" @@ -356,7 +391,7 @@ def __init__( password: Optional[str] = None, certificate_policy: Optional["_models.CertificatePolicy"] = None, certificate_attributes: Optional["_models.CertificateAttributes"] = None, - tags: Optional[Dict[str, str]] = None, + tags: Optional[dict[str, str]] = None, preserve_cert_order: Optional[bool] = None, ) -> None: ... @@ -380,9 +415,13 @@ class CertificateIssuerItem(_Model): :vartype provider: str """ - id: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + id: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Certificate Identifier.""" - provider: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + provider: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """The issuer provider.""" @overload @@ -418,7 +457,9 @@ class CertificateIssuerSetParameters(_Model): :vartype attributes: ~azure.keyvault.certificates._generated.models.IssuerAttributes """ - provider: str = rest_field(visibility=["read", "create", "update", "delete", "query"]) + provider: str = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """The issuer provider. Required.""" credentials: Optional["_models.IssuerCredentials"] = rest_field( visibility=["read", "create", "update", "delete", "query"] @@ -468,7 +509,9 @@ class CertificateIssuerUpdateParameters(_Model): :vartype attributes: ~azure.keyvault.certificates._generated.models.IssuerAttributes """ - provider: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + provider: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """The issuer provider.""" credentials: Optional["_models.IssuerCredentials"] = rest_field( visibility=["read", "create", "update", "delete", "query"] @@ -517,16 +560,22 @@ class CertificateItem(_Model): :vartype x509_thumbprint: bytes """ - id: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + id: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Certificate identifier.""" attributes: Optional["_models.CertificateAttributes"] = rest_field( visibility=["read", "create", "update", "delete", "query"] ) """The certificate management attributes.""" - tags: Optional[Dict[str, str]] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + tags: Optional[dict[str, str]] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Application specific metadata in the form of key-value pairs.""" x509_thumbprint: Optional[bytes] = rest_field( - name="x5t", visibility=["read", "create", "update", "delete", "query"], format="base64url" + name="x5t", + visibility=["read", "create", "update", "delete", "query"], + format="base64url", ) """Thumbprint of the certificate.""" @@ -536,7 +585,7 @@ def __init__( *, id: Optional[str] = None, # pylint: disable=redefined-builtin attributes: Optional["_models.CertificateAttributes"] = None, - tags: Optional[Dict[str, str]] = None, + tags: Optional[dict[str, str]] = None, x509_thumbprint: Optional[bytes] = None, ) -> None: ... @@ -563,24 +612,28 @@ class CertificateMergeParameters(_Model): :vartype tags: dict[str, str] """ - x509_certificates: List[bytes] = rest_field( - name="x5c", visibility=["read", "create", "update", "delete", "query"], format="base64" + x509_certificates: list[bytes] = rest_field( + name="x5c", + visibility=["read", "create", "update", "delete", "query"], + format="base64", ) """The certificate or the certificate chain to merge. Required.""" certificate_attributes: Optional["_models.CertificateAttributes"] = rest_field( name="attributes", visibility=["read", "create", "update", "delete", "query"] ) """The attributes of the certificate (optional).""" - tags: Optional[Dict[str, str]] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + tags: Optional[dict[str, str]] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Application specific metadata in the form of key-value pairs.""" @overload def __init__( self, *, - x509_certificates: List[bytes], + x509_certificates: list[bytes], certificate_attributes: Optional["_models.CertificateAttributes"] = None, - tags: Optional[Dict[str, str]] = None, + tags: Optional[dict[str, str]] = None, ) -> None: ... @overload @@ -628,26 +681,39 @@ class CertificateOperation(_Model): name="issuer", visibility=["read", "create", "update", "delete", "query"] ) """Parameters for the issuer of the X509 component of a certificate.""" - csr: Optional[bytes] = rest_field(visibility=["read", "create", "update", "delete", "query"], format="base64") + csr: Optional[bytes] = rest_field( + visibility=["read", "create", "update", "delete", "query"], format="base64" + ) """The certificate signing request (CSR) that is being used in the certificate operation.""" - cancellation_requested: Optional[bool] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + cancellation_requested: Optional[bool] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Indicates if cancellation was requested on the certificate operation.""" - status: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + status: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Status of the certificate operation.""" - status_details: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + status_details: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """The status details of the certificate operation.""" error: Optional["_models.KeyVaultErrorError"] = rest_field( visibility=["read", "create", "update", "delete", "query"] ) """Error encountered, if any, during the certificate operation.""" - target: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + target: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Location which contains the result of the certificate operation.""" preserve_cert_order: Optional[bool] = rest_field( - name="preserveCertOrder", visibility=["read", "create", "update", "delete", "query"] + name="preserveCertOrder", + visibility=["read", "create", "update", "delete", "query"], ) """Specifies whether the certificate chain preserves its original order. The default value is false, which sets the leaf certificate at index 0.""" - request_id: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + request_id: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Identifier for the certificate operation.""" @overload @@ -684,7 +750,9 @@ class CertificateOperationUpdateParameter(_Model): :vartype cancellation_requested: bool """ - cancellation_requested: bool = rest_field(visibility=["read", "create", "update", "delete", "query"]) + cancellation_requested: bool = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Indicates if cancellation was requested on the certificate operation. Required.""" @overload @@ -736,11 +804,14 @@ class CertificatePolicy(_Model): name="secret_props", visibility=["read", "create", "update", "delete", "query"] ) """Properties of the secret backing a certificate.""" - x509_certificate_properties: Optional["_models.X509CertificateProperties"] = rest_field( - name="x509_props", visibility=["read", "create", "update", "delete", "query"] + x509_certificate_properties: Optional["_models.X509CertificateProperties"] = ( + rest_field( + name="x509_props", + visibility=["read", "create", "update", "delete", "query"], + ) ) """Properties of the X509 component of a certificate.""" - lifetime_actions: Optional[List["_models.LifetimeAction"]] = rest_field( + lifetime_actions: Optional[list["_models.LifetimeAction"]] = rest_field( visibility=["read", "create", "update", "delete", "query"] ) """Actions that will be performed by Key Vault over the lifetime of a certificate.""" @@ -759,8 +830,10 @@ def __init__( *, key_properties: Optional["_models.KeyProperties"] = None, secret_properties: Optional["_models.SecretProperties"] = None, - x509_certificate_properties: Optional["_models.X509CertificateProperties"] = None, - lifetime_actions: Optional[List["_models.LifetimeAction"]] = None, + x509_certificate_properties: Optional[ + "_models.X509CertificateProperties" + ] = None, + lifetime_actions: Optional[list["_models.LifetimeAction"]] = None, issuer_parameters: Optional["_models.IssuerParameters"] = None, attributes: Optional["_models.CertificateAttributes"] = None, ) -> None: ... @@ -785,7 +858,9 @@ class CertificateRestoreParameters(_Model): """ certificate_bundle_backup: bytes = rest_field( - name="value", visibility=["read", "create", "update", "delete", "query"], format="base64url" + name="value", + visibility=["read", "create", "update", "delete", "query"], + format="base64url", ) """The backup blob associated with a certificate bundle. Required.""" @@ -827,7 +902,9 @@ class CertificateUpdateParameters(_Model): name="attributes", visibility=["read", "create", "update", "delete", "query"] ) """The attributes of the certificate (optional).""" - tags: Optional[Dict[str, str]] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + tags: Optional[dict[str, str]] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Application specific metadata in the form of key-value pairs.""" @overload @@ -836,7 +913,7 @@ def __init__( *, certificate_policy: Optional["_models.CertificatePolicy"] = None, certificate_attributes: Optional["_models.CertificateAttributes"] = None, - tags: Optional[Dict[str, str]] = None, + tags: Optional[dict[str, str]] = None, ) -> None: ... @overload @@ -861,11 +938,17 @@ class Contact(_Model): :vartype phone: str """ - email_address: Optional[str] = rest_field(name="email", visibility=["read", "create", "update", "delete", "query"]) + email_address: Optional[str] = rest_field( + name="email", visibility=["read", "create", "update", "delete", "query"] + ) """Email address.""" - name: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + name: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Name.""" - phone: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + phone: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Phone number.""" @overload @@ -899,7 +982,7 @@ class Contacts(_Model): id: Optional[str] = rest_field(visibility=["read"]) """Identifier for the contacts collection.""" - contact_list: Optional[List["_models.Contact"]] = rest_field( + contact_list: Optional[list["_models.Contact"]] = rest_field( name="contacts", visibility=["read", "create", "update", "delete", "query"] ) """The contact list for the vault certificates.""" @@ -908,7 +991,7 @@ class Contacts(_Model): def __init__( self, *, - contact_list: Optional[List["_models.Contact"]] = None, + contact_list: Optional[list["_models.Contact"]] = None, ) -> None: ... @overload @@ -939,7 +1022,7 @@ class DeletedCertificateBundle(_Model): :ivar cer: CER contents of x509 certificate. :vartype cer: bytes :ivar content_type: The content type of the secret. eg. 'application/x-pem-file' or - 'application/x-pkcs12',. + 'application/x-pkcs12'. :vartype content_type: str :ivar attributes: The certificate attributes. :vartype attributes: ~azure.keyvault.certificates._generated.models.CertificateAttributes @@ -963,24 +1046,31 @@ class DeletedCertificateBundle(_Model): """The key id.""" sid: Optional[str] = rest_field(visibility=["read"]) """The secret id.""" - x509_thumbprint: Optional[bytes] = rest_field(name="x5t", visibility=["read"], format="base64url") + x509_thumbprint: Optional[bytes] = rest_field( + name="x5t", visibility=["read"], format="base64url" + ) """Thumbprint of the certificate.""" policy: Optional["_models.CertificatePolicy"] = rest_field(visibility=["read"]) """The management policy.""" - cer: Optional[bytes] = rest_field(visibility=["read", "create", "update", "delete", "query"], format="base64") + cer: Optional[bytes] = rest_field( + visibility=["read", "create", "update", "delete", "query"], format="base64" + ) """CER contents of x509 certificate.""" content_type: Optional[str] = rest_field( name="contentType", visibility=["read", "create", "update", "delete", "query"] ) - """The content type of the secret. eg. 'application/x-pem-file' or 'application/x-pkcs12',.""" + """The content type of the secret. eg. 'application/x-pem-file' or 'application/x-pkcs12'.""" attributes: Optional["_models.CertificateAttributes"] = rest_field( visibility=["read", "create", "update", "delete", "query"] ) """The certificate attributes.""" - tags: Optional[Dict[str, str]] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + tags: Optional[dict[str, str]] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Application specific metadata in the form of key-value pairs.""" preserve_cert_order: Optional[bool] = rest_field( - name="preserveCertOrder", visibility=["read", "create", "update", "delete", "query"] + name="preserveCertOrder", + visibility=["read", "create", "update", "delete", "query"], ) """Specifies whether the certificate chain preserves its original order. The default value is false, which sets the leaf certificate at index 0.""" @@ -1004,7 +1094,7 @@ def __init__( cer: Optional[bytes] = None, content_type: Optional[str] = None, attributes: Optional["_models.CertificateAttributes"] = None, - tags: Optional[Dict[str, str]] = None, + tags: Optional[dict[str, str]] = None, preserve_cert_order: Optional[bool] = None, recovery_id: Optional[str] = None, ) -> None: ... @@ -1040,16 +1130,22 @@ class DeletedCertificateItem(_Model): :vartype deleted_date: ~datetime.datetime """ - id: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + id: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Certificate identifier.""" attributes: Optional["_models.CertificateAttributes"] = rest_field( visibility=["read", "create", "update", "delete", "query"] ) """The certificate management attributes.""" - tags: Optional[Dict[str, str]] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + tags: Optional[dict[str, str]] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Application specific metadata in the form of key-value pairs.""" x509_thumbprint: Optional[bytes] = rest_field( - name="x5t", visibility=["read", "create", "update", "delete", "query"], format="base64url" + name="x5t", + visibility=["read", "create", "update", "delete", "query"], + format="base64url", ) """Thumbprint of the certificate.""" recovery_id: Optional[str] = rest_field( @@ -1071,7 +1167,7 @@ def __init__( *, id: Optional[str] = None, # pylint: disable=redefined-builtin attributes: Optional["_models.CertificateAttributes"] = None, - tags: Optional[Dict[str, str]] = None, + tags: Optional[dict[str, str]] = None, x509_thumbprint: Optional[bytes] = None, recovery_id: Optional[str] = None, ) -> None: ... @@ -1098,11 +1194,17 @@ class IssuerAttributes(_Model): :vartype updated: ~datetime.datetime """ - enabled: Optional[bool] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + enabled: Optional[bool] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Determines whether the issuer is enabled.""" - created: Optional[datetime.datetime] = rest_field(visibility=["read"], format="unix-timestamp") + created: Optional[datetime.datetime] = rest_field( + visibility=["read"], format="unix-timestamp" + ) """Creation time in UTC.""" - updated: Optional[datetime.datetime] = rest_field(visibility=["read"], format="unix-timestamp") + updated: Optional[datetime.datetime] = rest_field( + visibility=["read"], format="unix-timestamp" + ) """Last updated time in UTC.""" @overload @@ -1141,7 +1243,9 @@ class IssuerBundle(_Model): id: Optional[str] = rest_field(visibility=["read"]) """Identifier for the issuer object.""" - provider: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + provider: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """The issuer provider.""" credentials: Optional["_models.IssuerCredentials"] = rest_field( visibility=["read", "create", "update", "delete", "query"] @@ -1186,9 +1290,13 @@ class IssuerCredentials(_Model): :vartype password: str """ - account_id: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + account_id: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """The user name/account name/account id.""" - password: Optional[str] = rest_field(name="pwd", visibility=["read", "create", "update", "delete", "query"]) + password: Optional[str] = rest_field( + name="pwd", visibility=["read", "create", "update", "delete", "query"] + ) """The password/secret/account key.""" @overload @@ -1224,12 +1332,17 @@ class IssuerParameters(_Model): :vartype certificate_transparency: bool """ - name: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + name: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Name of the referenced issuer object or reserved names; for example, 'Self' or 'Unknown'.""" - certificate_type: Optional[str] = rest_field(name="cty", visibility=["read", "create", "update", "delete", "query"]) + certificate_type: Optional[str] = rest_field( + name="cty", visibility=["read", "create", "update", "delete", "query"] + ) """Certificate type as supported by the provider (optional); for example 'OV-SSL', 'EV-SSL'.""" certificate_transparency: Optional[bool] = rest_field( - name="cert_transparency", visibility=["read", "create", "update", "delete", "query"] + name="cert_transparency", + visibility=["read", "create", "update", "delete", "query"], ) """Indicates if the certificates generated under this policy should be published to certificate transparency logs.""" @@ -1272,7 +1385,9 @@ class KeyProperties(_Model): :vartype curve: str or ~azure.keyvault.certificates._generated.models.JsonWebKeyCurveName """ - exportable: Optional[bool] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + exportable: Optional[bool] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Indicates if the private key can be exported. Release policy must be provided when creating the first version of an exportable key.""" key_type: Optional[Union[str, "_models.JsonWebKeyType"]] = rest_field( @@ -1280,9 +1395,13 @@ class KeyProperties(_Model): ) """The type of key pair to be used for the certificate. Known values are: \"EC\", \"EC-HSM\", \"RSA\", \"RSA-HSM\", \"oct\", and \"oct-HSM\".""" - key_size: Optional[int] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + key_size: Optional[int] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """The key size in bits. For example: 2048, 3072, or 4096 for RSA.""" - reuse_key: Optional[bool] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + reuse_key: Optional[bool] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Indicates if the same key pair will be used on certificate renewal.""" curve: Optional[Union[str, "_models.JsonWebKeyCurveName"]] = rest_field( name="crv", visibility=["read", "create", "update", "delete", "query"] @@ -1338,7 +1457,9 @@ class KeyVaultErrorError(_Model): """The error code.""" message: Optional[str] = rest_field(visibility=["read"]) """The error message.""" - inner_error: Optional["_models.KeyVaultErrorError"] = rest_field(name="innererror", visibility=["read"]) + inner_error: Optional["_models.KeyVaultErrorError"] = rest_field( + name="innererror", visibility=["read"] + ) """The key vault server error.""" @@ -1351,9 +1472,13 @@ class LifetimeAction(_Model): :vartype action: ~azure.keyvault.certificates._generated.models.Action """ - trigger: Optional["_models.Trigger"] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + trigger: Optional["_models.Trigger"] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """The condition that will execute the action.""" - action: Optional["_models.Action"] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + action: Optional["_models.Action"] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """The action that will be executed.""" @overload @@ -1385,9 +1510,11 @@ class OrganizationDetails(_Model): list[~azure.keyvault.certificates._generated.models.AdministratorDetails] """ - id: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + id: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Id of the organization.""" - admin_details: Optional[List["_models.AdministratorDetails"]] = rest_field( + admin_details: Optional[list["_models.AdministratorDetails"]] = rest_field( visibility=["read", "create", "update", "delete", "query"] ) """Details of the organization administrator.""" @@ -1397,7 +1524,7 @@ def __init__( self, *, id: Optional[str] = None, # pylint: disable=redefined-builtin - admin_details: Optional[List["_models.AdministratorDetails"]] = None, + admin_details: Optional[list["_models.AdministratorDetails"]] = None, ) -> None: ... @overload @@ -1442,30 +1569,50 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: class SubjectAlternativeNames(_Model): - """The subject alternate names of a X509 object. + """The Subject Alternative Names of a X509 object. :ivar emails: Email addresses. :vartype emails: list[str] - :ivar dns_names: Domain names. + :ivar dns_names: Domain Names. :vartype dns_names: list[str] - :ivar upns: User principal names. + :ivar upns: User Principal Names. :vartype upns: list[str] + :ivar uris: Uniform Resource Identifiers. + :vartype uris: list[str] + :ivar ip_addresses: IP addresses; supports IPv4 and IPv6. + :vartype ip_addresses: list[str] """ - emails: Optional[List[str]] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + emails: Optional[list[str]] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Email addresses.""" - dns_names: Optional[List[str]] = rest_field(visibility=["read", "create", "update", "delete", "query"]) - """Domain names.""" - upns: Optional[List[str]] = rest_field(visibility=["read", "create", "update", "delete", "query"]) - """User principal names.""" + dns_names: Optional[list[str]] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) + """Domain Names.""" + upns: Optional[list[str]] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) + """User Principal Names.""" + uris: Optional[list[str]] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) + """Uniform Resource Identifiers.""" + ip_addresses: Optional[list[str]] = rest_field( + name="ipAddresses", visibility=["read", "create", "update", "delete", "query"] + ) + """IP addresses; supports IPv4 and IPv6.""" @overload def __init__( self, *, - emails: Optional[List[str]] = None, - dns_names: Optional[List[str]] = None, - upns: Optional[List[str]] = None, + emails: Optional[list[str]] = None, + dns_names: Optional[list[str]] = None, + upns: Optional[list[str]] = None, + uris: Optional[list[str]] = None, + ip_addresses: Optional[list[str]] = None, ) -> None: ... @overload @@ -1491,9 +1638,13 @@ class Trigger(_Model): :vartype days_before_expiry: int """ - lifetime_percentage: Optional[int] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + lifetime_percentage: Optional[int] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Percentage of lifetime at which to trigger. Value should be between 1 and 99.""" - days_before_expiry: Optional[int] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + days_before_expiry: Optional[int] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """Days before expiry to attempt renewal. Value should be between 1 and validity_in_months multiplied by 27. If validity_in_months is 36, then value should be between 1 and 972 (36 * 27).""" @@ -1533,20 +1684,25 @@ class X509CertificateProperties(_Model): :vartype validity_in_months: int """ - subject: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + subject: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """The subject name. Should be a valid X509 distinguished Name.""" - ekus: Optional[List[str]] = rest_field(visibility=["read", "create", "update", "delete", "query"]) + ekus: Optional[list[str]] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) """The enhanced key usage.""" subject_alternative_names: Optional["_models.SubjectAlternativeNames"] = rest_field( name="sans", visibility=["read", "create", "update", "delete", "query"] ) """The subject alternative names.""" - key_usage: Optional[List[Union[str, "_models.KeyUsageType"]]] = rest_field( + key_usage: Optional[list[Union[str, "_models.KeyUsageType"]]] = rest_field( visibility=["read", "create", "update", "delete", "query"] ) """Defines how the certificate's key may be used.""" validity_in_months: Optional[int] = rest_field( - name="validity_months", visibility=["read", "create", "update", "delete", "query"] + name="validity_months", + visibility=["read", "create", "update", "delete", "query"], ) """The duration that the certificate is valid in months.""" @@ -1555,9 +1711,9 @@ def __init__( self, *, subject: Optional[str] = None, - ekus: Optional[List[str]] = None, + ekus: Optional[list[str]] = None, subject_alternative_names: Optional["_models.SubjectAlternativeNames"] = None, - key_usage: Optional[List[Union[str, "_models.KeyUsageType"]]] = None, + key_usage: Optional[list[Union[str, "_models.KeyUsageType"]]] = None, validity_in_months: Optional[int] = None, ) -> None: ... diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_models.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_models.py index ad50d3fd72af..18a9ec3a9647 100644 --- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_models.py +++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_models.py @@ -51,7 +51,9 @@ def __repr__(self) -> str: return result[:1024] @classmethod - def _from_admin_detail(cls, admin_detail: models.AdministratorDetails) -> "AdministratorContact": + def _from_admin_detail( + cls, admin_detail: models.AdministratorDetails + ) -> "AdministratorContact": return cls( email=admin_detail.email_address, first_name=admin_detail.first_name, @@ -97,20 +99,33 @@ class CertificateOperationError(object): :type inner_error: ~azure.keyvault.certificates.CertificateOperationError or None """ - def __init__(self, code: str, message: str, inner_error: "Optional[CertificateOperationError]") -> None: + def __init__( + self, + code: str, + message: str, + inner_error: "Optional[CertificateOperationError]", + ) -> None: self._code = code self._message = message self._inner_error = inner_error def __repr__(self) -> str: - return f"CertificateOperationError({self.code}, {self.message}, {self.inner_error})"[:1024] + return f"CertificateOperationError({self.code}, {self.message}, {self.inner_error})"[ + :1024 + ] @classmethod - def _from_error_bundle(cls, error_bundle: models.KeyVaultErrorError) -> "CertificateOperationError": + def _from_error_bundle( + cls, error_bundle: models.KeyVaultErrorError + ) -> "CertificateOperationError": return cls( code=error_bundle.code, # type: ignore message=error_bundle.message, # type: ignore - inner_error=cls._from_error_bundle(error_bundle.inner_error) if error_bundle.inner_error else None, + inner_error=( + cls._from_error_bundle(error_bundle.inner_error) + if error_bundle.inner_error + else None + ), ) @property @@ -312,7 +327,7 @@ def version(self) -> Optional[str]: def preserve_order(self) -> Optional[bool]: """Whether the certificate order should be preserved. - :returns: Specifies whether the certificate chain preserves its original order. The default value is False, + :returns: Specifies whether the certificate chain preserves its original order. The default value is False, which sets the leaf certificate at index 0. :rtype: bool or None """ @@ -347,18 +362,24 @@ def __repr__(self) -> str: return f""[:1024] @classmethod - def _from_certificate_bundle(cls, certificate_bundle: models.CertificateBundle) -> "KeyVaultCertificate": + def _from_certificate_bundle( + cls, certificate_bundle: models.CertificateBundle + ) -> "KeyVaultCertificate": # pylint:disable=protected-access if certificate_bundle.policy: - policy: Optional[CertificatePolicy] = CertificatePolicy._from_certificate_policy_bundle( - certificate_bundle.policy + policy: Optional[CertificatePolicy] = ( + CertificatePolicy._from_certificate_policy_bundle( + certificate_bundle.policy + ) ) else: policy = None return cls( - properties=CertificateProperties._from_certificate_bundle(certificate_bundle), + properties=CertificateProperties._from_certificate_bundle( + certificate_bundle + ), key_id=certificate_bundle.kid, secret_id=certificate_bundle.sid, policy=policy, @@ -513,7 +534,9 @@ def __init__( preserve_order: Optional[bool] = False, ) -> None: self._id = cert_operation_id - self._vault_id = parse_key_vault_id(cert_operation_id) if cert_operation_id else None + self._vault_id = ( + parse_key_vault_id(cert_operation_id) if cert_operation_id else None + ) self._issuer_name = issuer_name self._certificate_type = certificate_type self._certificate_transparency = certificate_transparency @@ -544,7 +567,9 @@ def _from_certificate_operation_bundle( else None ), # 2016-10-01 IssuerParameters doesn't have certificate_transparency - certificate_transparency=getattr(issuer_parameters, "certificate_transparency", None), + certificate_transparency=getattr( + issuer_parameters, "certificate_transparency", None + ), csr=certificate_operation_bundle.csr, cancellation_requested=certificate_operation_bundle.cancellation_requested, status=certificate_operation_bundle.status, @@ -710,6 +735,12 @@ class CertificatePolicy(object): :keyword san_user_principal_names: Subject alternative user principal names of the X509 object. Either subject or one of the subject alternative name parameters are required for creating a certificate. :paramtype san_user_principal_names: list[str] or None + :keyword san_uris: Subject alternative URIs of the X509 object. Either subject or one of the subject alternative + name parameters are required for creating a certificate. + :paramtype san_uris: list[str] or None + :keyword san_ip_addresses: Subject alternative IP addresses of the X509 object (supports IPv4 and IPv6). Either + subject or one of the subject alternative name parameters are required for creating a certificate. + :paramtype san_ip_addresses: list[str] or None :keyword exportable: Indicates if the private key can be exported. For valid values, see KeyType. :paramtype exportable: bool or None :keyword key_type: The type of key pair to be used for the certificate. @@ -761,7 +792,11 @@ def __init__( self._certificate_transparency = kwargs.pop("certificate_transparency", None) self._san_emails = kwargs.pop("san_emails", None) or None self._san_dns_names = kwargs.pop("san_dns_names", None) or None - self._san_user_principal_names = kwargs.pop("san_user_principal_names", None) or None + self._san_user_principal_names = ( + kwargs.pop("san_user_principal_names", None) or None + ) + self._san_uris = kwargs.pop("san_uris", None) or None + self._san_ip_addresses = kwargs.pop("san_ip_addresses", None) or None @classmethod def get_default(cls) -> "CertificatePolicy": @@ -772,15 +807,21 @@ def __repr__(self) -> str: def _to_certificate_policy_bundle(self) -> models.CertificatePolicy: if self.issuer_name or self.certificate_type or self.certificate_transparency: - issuer_parameters: Optional[models.IssuerParameters] = models.IssuerParameters( - name=self.issuer_name, - certificate_type=self.certificate_type, - certificate_transparency=self.certificate_transparency, # 2016-10-01 model will ignore this + issuer_parameters: Optional[models.IssuerParameters] = ( + models.IssuerParameters( + name=self.issuer_name, + certificate_type=self.certificate_type, + certificate_transparency=self.certificate_transparency, # 2016-10-01 model will ignore this + ) ) else: issuer_parameters = None - if self.enabled is not None or self.created_on is not None or self.updated_on is not None: + if ( + self.enabled is not None + or self.created_on is not None + or self.updated_on is not None + ): attributes = models.CertificateAttributes( { "enabled": self.enabled, @@ -814,6 +855,8 @@ def _to_certificate_policy_bundle(self) -> models.CertificatePolicy: or self.san_emails or self.san_user_principal_names or self.san_dns_names + or self.san_uris + or self.san_ip_addresses or self.validity_in_months ): if self.key_usage: @@ -823,19 +866,31 @@ def _to_certificate_policy_bundle(self) -> models.CertificatePolicy: else: key_usage = None - x509_properties: Optional[models.X509CertificateProperties] = models.X509CertificateProperties( - subject=self.subject, - ekus=self.enhanced_key_usage, - subject_alternative_names=models.SubjectAlternativeNames( - emails=self.san_emails, upns=self.san_user_principal_names, dns_names=self.san_dns_names - ), - key_usage=key_usage, - validity_in_months=self.validity_in_months, + x509_properties: Optional[models.X509CertificateProperties] = ( + models.X509CertificateProperties( + subject=self.subject, + ekus=self.enhanced_key_usage, + subject_alternative_names=models.SubjectAlternativeNames( + emails=self.san_emails, + upns=self.san_user_principal_names, + dns_names=self.san_dns_names, + uris=self.san_uris, + ip_addresses=self.san_ip_addresses, + ), + key_usage=key_usage, + validity_in_months=self.validity_in_months, + ) ) else: x509_properties = None - if self.exportable or self.key_type or self.key_size or self.reuse_key or self.key_curve_name: + if ( + self.exportable + or self.key_type + or self.key_size + or self.reuse_key + or self.key_curve_name + ): key_properties: Optional[models.KeyProperties] = models.KeyProperties( exportable=self.exportable, key_type=self.key_type, @@ -847,8 +902,8 @@ def _to_certificate_policy_bundle(self) -> models.CertificatePolicy: key_properties = None if self.content_type: - secret_properties: Optional[models.SecretProperties] = models.SecretProperties( - content_type=self.content_type + secret_properties: Optional[models.SecretProperties] = ( + models.SecretProperties(content_type=self.content_type) ) else: secret_properties = None @@ -873,41 +928,73 @@ def _from_certificate_policy_bundle( if certificate_policy_bundle.lifetime_actions: lifetime_actions: Optional[List[LifetimeAction]] = [ LifetimeAction( - action=CertificatePolicyAction(item.action.action_type) if item.action else None, - lifetime_percentage=item.trigger.lifetime_percentage if item.trigger else None, - days_before_expiry=item.trigger.days_before_expiry if item.trigger else None, + action=( + CertificatePolicyAction(item.action.action_type) + if item.action + else None + ), + lifetime_percentage=( + item.trigger.lifetime_percentage if item.trigger else None + ), + days_before_expiry=( + item.trigger.days_before_expiry if item.trigger else None + ), ) for item in certificate_policy_bundle.lifetime_actions ] else: lifetime_actions = None - x509_certificate_properties = certificate_policy_bundle.x509_certificate_properties + x509_certificate_properties = ( + certificate_policy_bundle.x509_certificate_properties + ) if x509_certificate_properties and x509_certificate_properties.key_usage: - key_usage: Optional[List[KeyUsageType]] = [KeyUsageType(k) for k in x509_certificate_properties.key_usage] + key_usage: Optional[List[KeyUsageType]] = [ + KeyUsageType(k) for k in x509_certificate_properties.key_usage + ] else: key_usage = None key_properties = certificate_policy_bundle.key_properties - curve_name = getattr(key_properties, "curve", None) # missing from 2016-10-01 KeyProperties + curve_name = getattr( + key_properties, "curve", None + ) # missing from 2016-10-01 KeyProperties if curve_name: curve_name = KeyCurveName(curve_name) issuer_parameters = certificate_policy_bundle.issuer_parameters return cls( issuer_name=issuer_parameters.name if issuer_parameters else None, - subject=(x509_certificate_properties.subject if x509_certificate_properties else None), - certificate_type=issuer_parameters.certificate_type if issuer_parameters else None, + subject=( + x509_certificate_properties.subject + if x509_certificate_properties + else None + ), + certificate_type=( + issuer_parameters.certificate_type if issuer_parameters else None + ), # 2016-10-01 IssuerParameters doesn't have certificate_transparency - certificate_transparency=getattr(issuer_parameters, "certificate_transparency", None), + certificate_transparency=getattr( + issuer_parameters, "certificate_transparency", None + ), lifetime_actions=lifetime_actions, exportable=key_properties.exportable if key_properties else None, - key_type=KeyType(key_properties.key_type) if key_properties and key_properties.key_type else None, + key_type=( + KeyType(key_properties.key_type) + if key_properties and key_properties.key_type + else None + ), key_size=key_properties.key_size if key_properties else None, reuse_key=key_properties.reuse_key if key_properties else None, key_curve_name=curve_name, - enhanced_key_usage=x509_certificate_properties.ekus if x509_certificate_properties else None, + enhanced_key_usage=( + x509_certificate_properties.ekus + if x509_certificate_properties + else None + ), key_usage=key_usage, content_type=( - CertificateContentType(certificate_policy_bundle.secret_properties.content_type) + CertificateContentType( + certificate_policy_bundle.secret_properties.content_type + ) if certificate_policy_bundle.secret_properties and certificate_policy_bundle.secret_properties.content_type else None @@ -915,21 +1002,38 @@ def _from_certificate_policy_bundle( attributes=certificate_policy_bundle.attributes, san_emails=( x509_certificate_properties.subject_alternative_names.emails - if x509_certificate_properties and x509_certificate_properties.subject_alternative_names + if x509_certificate_properties + and x509_certificate_properties.subject_alternative_names else None ), san_user_principal_names=( x509_certificate_properties.subject_alternative_names.upns - if x509_certificate_properties and x509_certificate_properties.subject_alternative_names + if x509_certificate_properties + and x509_certificate_properties.subject_alternative_names else None ), san_dns_names=( x509_certificate_properties.subject_alternative_names.dns_names - if x509_certificate_properties and x509_certificate_properties.subject_alternative_names + if x509_certificate_properties + and x509_certificate_properties.subject_alternative_names + else None + ), + san_uris=( + x509_certificate_properties.subject_alternative_names.uris + if x509_certificate_properties + and x509_certificate_properties.subject_alternative_names + else None + ), + san_ip_addresses=( + x509_certificate_properties.subject_alternative_names.ip_addresses + if x509_certificate_properties + and x509_certificate_properties.subject_alternative_names else None ), validity_in_months=( - x509_certificate_properties.validity_in_months if x509_certificate_properties else None + x509_certificate_properties.validity_in_months + if x509_certificate_properties + else None ), ) @@ -1041,6 +1145,24 @@ def san_user_principal_names(self) -> Optional[List[str]]: """ return self._san_user_principal_names + @property + def san_uris(self) -> Optional[List[str]]: + """The subject alternative URIs. + + :returns: The subject alternative URIs, as a list. + :rtype: list[str] or None + """ + return self._san_uris + + @property + def san_ip_addresses(self) -> Optional[List[str]]: + """The subject alternative IP addresses (supports IPv4 and IPv6). + + :returns: The subject alternative IP addresses, as a list. + :rtype: list[str] or None + """ + return self._san_ip_addresses + @property def validity_in_months(self) -> Optional[int]: """The duration that the certificate is valid for in months. @@ -1125,20 +1247,35 @@ class CertificateContact(object): :type phone: str or None """ - def __init__(self, email: Optional[str] = None, name: Optional[str] = None, phone: Optional[str] = None) -> None: + def __init__( + self, + email: Optional[str] = None, + name: Optional[str] = None, + phone: Optional[str] = None, + ) -> None: self._email = email self._name = name self._phone = phone def __repr__(self) -> str: - return f"CertificateContact(email={self.email}, name={self.name}, phone={self.phone})"[:1024] + return f"CertificateContact(email={self.email}, name={self.name}, phone={self.phone})"[ + :1024 + ] def _to_certificate_contacts_item(self) -> models.Contact: - return models.Contact(email_address=self.email, name=self.name, phone=self.phone) + return models.Contact( + email_address=self.email, name=self.name, phone=self.phone + ) @classmethod - def _from_certificate_contacts_item(cls, contact_item: models.Contact) -> "CertificateContact": - return cls(email=contact_item.email_address, name=contact_item.name, phone=contact_item.phone) + def _from_certificate_contacts_item( + cls, contact_item: models.Contact + ) -> "CertificateContact": + return cls( + email=contact_item.email_address, + name=contact_item.name, + phone=contact_item.phone, + ) @property def email(self) -> Optional[str]: @@ -1253,19 +1390,41 @@ def __repr__(self) -> str: return f""[:1024] @classmethod - def _from_issuer_bundle(cls, issuer_bundle: models.IssuerBundle) -> "CertificateIssuer": + def _from_issuer_bundle( + cls, issuer_bundle: models.IssuerBundle + ) -> "CertificateIssuer": admin_contacts = [] - admin_details = issuer_bundle.organization_details.admin_details if issuer_bundle.organization_details else None + admin_details = ( + issuer_bundle.organization_details.admin_details + if issuer_bundle.organization_details + else None + ) if admin_details: # pylint:disable=protected-access for admin_detail in admin_details: - admin_contacts.append(AdministratorContact._from_admin_detail(admin_detail)) + admin_contacts.append( + AdministratorContact._from_admin_detail(admin_detail) + ) return cls( - provider=IssuerProperties._from_issuer_item(issuer_bundle).provider, # pylint: disable=protected-access + provider=IssuerProperties._from_issuer_item( # pylint: disable=protected-access + issuer_bundle + ).provider, attributes=issuer_bundle.attributes, - account_id=issuer_bundle.credentials.account_id if issuer_bundle.credentials else None, - password=issuer_bundle.credentials.password if issuer_bundle.credentials else None, - organization_id=issuer_bundle.organization_details.id if issuer_bundle.organization_details else None, + account_id=( + issuer_bundle.credentials.account_id + if issuer_bundle.credentials + else None + ), + password=( + issuer_bundle.credentials.password + if issuer_bundle.credentials + else None + ), + organization_id=( + issuer_bundle.organization_details.id + if issuer_bundle.organization_details + else None + ), admin_contacts=admin_contacts, issuer_id=issuer_bundle.id, ) @@ -1449,7 +1608,9 @@ def __init__( cer: Optional[bytearray] = None, **kwargs: Any, ) -> None: - super(DeletedCertificate, self).__init__(properties=properties, policy=policy, cer=cer, **kwargs) + super(DeletedCertificate, self).__init__( + properties=properties, policy=policy, cer=cer, **kwargs + ) self._deleted_on = kwargs.get("deleted_on", None) self._recovery_id = kwargs.get("recovery_id", None) self._scheduled_purge_date = kwargs.get("scheduled_purge_date", None) @@ -1480,10 +1641,14 @@ def _from_deleted_certificate_bundle( ) -> "DeletedCertificate": # pylint:disable=protected-access return cls( - properties=CertificateProperties._from_certificate_bundle(deleted_certificate_bundle), + properties=CertificateProperties._from_certificate_bundle( + deleted_certificate_bundle + ), key_id=deleted_certificate_bundle.kid, secret_id=deleted_certificate_bundle.sid, - policy=CertificatePolicy._from_certificate_policy_bundle(deleted_certificate_bundle.policy), + policy=CertificatePolicy._from_certificate_policy_bundle( + deleted_certificate_bundle.policy + ), cer=deleted_certificate_bundle.cer, # type: ignore deleted_on=deleted_certificate_bundle.deleted_date, recovery_id=deleted_certificate_bundle.recovery_id, diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_version.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_version.py index 81a6e1e8366d..1166529c1953 100644 --- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_version.py +++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_version.py @@ -3,4 +3,4 @@ # Licensed under the MIT License. # ------------------------------------ -VERSION = "4.10.1" +VERSION = "4.11.0" diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/aio/_client.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/aio/_client.py index bd6288a39369..27016d2a9964 100644 --- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/aio/_client.py +++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/aio/_client.py @@ -96,7 +96,14 @@ async def create_certificate( :caption: Create a certificate :dedent: 8 """ - if not (policy.san_emails or policy.san_user_principal_names or policy.san_dns_names or policy.subject): + if not ( + policy.san_emails + or policy.san_user_principal_names + or policy.san_dns_names + or policy.san_uris + or policy.san_ip_addresses + or policy.subject + ): raise ValueError(NO_SAN_OR_SUBJECT) polling_interval = kwargs.pop("_polling_interval", None) @@ -118,27 +125,46 @@ async def create_certificate( pipeline_response, cert_bundle = await self._client.create_certificate( certificate_name=certificate_name, parameters=parameters, - cls=lambda pipeline_response, deserialized, _: (pipeline_response, deserialized), - **kwargs + cls=lambda pipeline_response, deserialized, _: ( + pipeline_response, + deserialized, + ), + **kwargs, ) - create_certificate_operation = CertificateOperation._from_certificate_operation_bundle(cert_bundle) + create_certificate_operation = ( + CertificateOperation._from_certificate_operation_bundle(cert_bundle) + ) - command = partial(self.get_certificate_operation, certificate_name=certificate_name, **kwargs) + command = partial( + self.get_certificate_operation, certificate_name=certificate_name, **kwargs + ) - get_certificate_command = partial(self.get_certificate, certificate_name=certificate_name, **kwargs) + get_certificate_command = partial( + self.get_certificate, certificate_name=certificate_name, **kwargs + ) create_certificate_polling = CreateCertificatePollerAsync( pipeline_response=pipeline_response, get_certificate_command=get_certificate_command, interval=polling_interval, ) - def no_op(*_, **__) -> Any: # The deserialization callback is ignored based on polling implementation + + def no_op( + *_, **__ + ) -> ( + Any + ): # The deserialization callback is ignored based on polling implementation pass - return await AsyncLROPoller(command, create_certificate_operation, no_op, create_certificate_polling) + + return await AsyncLROPoller( + command, create_certificate_operation, no_op, create_certificate_polling + ) @distributed_trace_async - async def get_certificate(self, certificate_name: str, **kwargs: Any) -> KeyVaultCertificate: + async def get_certificate( + self, certificate_name: str, **kwargs: Any + ) -> KeyVaultCertificate: """Gets a certificate with its management policy attached. Requires certificates/get permission. Does not accept the version of the certificate as a parameter. To get a specific version of the @@ -161,9 +187,7 @@ async def get_certificate(self, certificate_name: str, **kwargs: Any) -> KeyVaul :dedent: 8 """ bundle = await self._client.get_certificate( - certificate_name=certificate_name, - certificate_version="", - **kwargs + certificate_name=certificate_name, certificate_version="", **kwargs ) return KeyVaultCertificate._from_certificate_bundle(certificate_bundle=bundle) @@ -194,14 +218,14 @@ async def get_certificate_version( :dedent: 8 """ bundle = await self._client.get_certificate( - certificate_name=certificate_name, - certificate_version=version, - **kwargs + certificate_name=certificate_name, certificate_version=version, **kwargs ) return KeyVaultCertificate._from_certificate_bundle(certificate_bundle=bundle) @distributed_trace_async - async def delete_certificate(self, certificate_name: str, **kwargs: Any) -> DeletedCertificate: + async def delete_certificate( + self, certificate_name: str, **kwargs: Any + ) -> DeletedCertificate: """Delete all versions of a certificate. Requires certificates/delete permission. If the vault has soft-delete enabled, deletion may take several seconds to complete. @@ -227,16 +251,25 @@ async def delete_certificate(self, certificate_name: str, **kwargs: Any) -> Dele polling_interval = 2 pipeline_response, deleted_cert_bundle = await self._client.delete_certificate( certificate_name=certificate_name, - cls=lambda pipeline_response, deserialized, _: (pipeline_response, deserialized), + cls=lambda pipeline_response, deserialized, _: ( + pipeline_response, + deserialized, + ), **kwargs, ) - deleted_certificate = DeletedCertificate._from_deleted_certificate_bundle(deleted_cert_bundle) + deleted_certificate = DeletedCertificate._from_deleted_certificate_bundle( + deleted_cert_bundle + ) polling_method = AsyncDeleteRecoverPollingMethod( # no recovery ID means soft-delete is disabled, in which case we initialize the poller as finished finished=deleted_certificate.recovery_id is None, pipeline_response=pipeline_response, - command=partial(self.get_deleted_certificate, certificate_name=certificate_name, **kwargs), + command=partial( + self.get_deleted_certificate, + certificate_name=certificate_name, + **kwargs, + ), final_resource=deleted_certificate, interval=polling_interval, ) @@ -245,7 +278,9 @@ async def delete_certificate(self, certificate_name: str, **kwargs: Any) -> Dele return polling_method.resource() @distributed_trace_async - async def get_deleted_certificate(self, certificate_name: str, **kwargs: Any) -> DeletedCertificate: + async def get_deleted_certificate( + self, certificate_name: str, **kwargs: Any + ) -> DeletedCertificate: """Get a deleted certificate. Possible only in a vault with soft-delete enabled. Requires certificates/get permission. Retrieves the deleted certificate information plus its attributes, such as @@ -270,10 +305,14 @@ async def get_deleted_certificate(self, certificate_name: str, **kwargs: Any) -> bundle = await self._client.get_deleted_certificate( certificate_name=certificate_name, **kwargs ) - return DeletedCertificate._from_deleted_certificate_bundle(deleted_certificate_bundle=bundle) + return DeletedCertificate._from_deleted_certificate_bundle( + deleted_certificate_bundle=bundle + ) @distributed_trace_async - async def purge_deleted_certificate(self, certificate_name: str, **kwargs: Any) -> None: + async def purge_deleted_certificate( + self, certificate_name: str, **kwargs: Any + ) -> None: """Permanently deletes a deleted certificate. Possible only in vaults with soft-delete enabled. Requires certificates/purge permission. Performs an irreversible deletion of the specified certificate, without @@ -294,7 +333,9 @@ async def purge_deleted_certificate(self, certificate_name: str, **kwargs: Any) ) @distributed_trace_async - async def recover_deleted_certificate(self, certificate_name: str, **kwargs: Any) -> KeyVaultCertificate: + async def recover_deleted_certificate( + self, certificate_name: str, **kwargs: Any + ) -> KeyVaultCertificate: """Recover a deleted certificate to its latest version. Possible only in a vault with soft-delete enabled. Requires certificates/recover permission. If the vault does not have soft-delete enabled, @@ -319,20 +360,29 @@ async def recover_deleted_certificate(self, certificate_name: str, **kwargs: Any polling_interval = kwargs.pop("_polling_interval", None) if polling_interval is None: polling_interval = 2 - pipeline_response, recovered_cert_bundle = await self._client.recover_deleted_certificate( - certificate_name=certificate_name, - cls=lambda pipeline_response, deserialized, _: (pipeline_response, deserialized), - **kwargs, + pipeline_response, recovered_cert_bundle = ( + await self._client.recover_deleted_certificate( + certificate_name=certificate_name, + cls=lambda pipeline_response, deserialized, _: ( + pipeline_response, + deserialized, + ), + **kwargs, + ) + ) + recovered_certificate = KeyVaultCertificate._from_certificate_bundle( + recovered_cert_bundle ) - recovered_certificate = KeyVaultCertificate._from_certificate_bundle(recovered_cert_bundle) - command = partial(self.get_certificate, certificate_name=certificate_name, **kwargs) + command = partial( + self.get_certificate, certificate_name=certificate_name, **kwargs + ) polling_method = AsyncDeleteRecoverPollingMethod( pipeline_response=pipeline_response, command=command, final_resource=recovered_certificate, finished=False, - interval=polling_interval + interval=polling_interval, ) await polling_method.run() @@ -389,21 +439,23 @@ async def import_certificate( parameters = self._models.CertificateImportParameters( base64_encoded_certificate=base64_encoded_certificate, password=password, - certificate_policy=policy._to_certificate_policy_bundle() if policy else None, + certificate_policy=( + policy._to_certificate_policy_bundle() if policy else None + ), certificate_attributes=attributes, tags=tags, preserve_cert_order=preserve_order, ) bundle = await self._client.import_certificate( - certificate_name=certificate_name, - parameters=parameters, - **kwargs + certificate_name=certificate_name, parameters=parameters, **kwargs ) return KeyVaultCertificate._from_certificate_bundle(certificate_bundle=bundle) @distributed_trace_async - async def get_certificate_policy(self, certificate_name: str, **kwargs: Any) -> CertificatePolicy: + async def get_certificate_policy( + self, certificate_name: str, **kwargs: Any + ) -> CertificatePolicy: """Gets the policy for a certificate. Requires certificates/get permission. Returns the specified certificate policy resources in the key vault. @@ -418,7 +470,9 @@ async def get_certificate_policy(self, certificate_name: str, **kwargs: Any) -> bundle = await self._client.get_certificate_policy( certificate_name=certificate_name, **kwargs ) - return CertificatePolicy._from_certificate_policy_bundle(certificate_policy_bundle=bundle) + return CertificatePolicy._from_certificate_policy_bundle( + certificate_policy_bundle=bundle + ) @distributed_trace_async async def update_certificate_policy( @@ -440,9 +494,11 @@ async def update_certificate_policy( bundle = await self._client.update_certificate_policy( certificate_name=certificate_name, certificate_policy=policy._to_certificate_policy_bundle(), - **kwargs + **kwargs, + ) + return CertificatePolicy._from_certificate_policy_bundle( + certificate_policy_bundle=bundle ) - return CertificatePolicy._from_certificate_policy_bundle(certificate_policy_bundle=bundle) @distributed_trace_async async def update_certificate_properties( @@ -490,7 +546,7 @@ async def update_certificate_properties( certificate_name=certificate_name, certificate_version=version or "", parameters=parameters, - **kwargs + **kwargs, ) return KeyVaultCertificate._from_certificate_bundle(certificate_bundle=bundle) @@ -525,7 +581,9 @@ async def backup_certificate(self, certificate_name: str, **kwargs: Any) -> byte return backup_result.value @distributed_trace_async - async def restore_certificate_backup(self, backup: bytes, **kwargs: Any) -> KeyVaultCertificate: + async def restore_certificate_backup( + self, backup: bytes, **kwargs: Any + ) -> KeyVaultCertificate: """Restore a certificate backup to the vault. Requires certificates/restore permission. This restores all versions of the certificate, with its name, attributes, and access control policies. If the @@ -548,8 +606,10 @@ async def restore_certificate_backup(self, backup: bytes, **kwargs: Any) -> KeyV :dedent: 8 """ bundle = await self._client.restore_certificate( - parameters=self._models.CertificateRestoreParameters(certificate_bundle_backup=backup), - **kwargs + parameters=self._models.CertificateRestoreParameters( + certificate_bundle_backup=backup + ), + **kwargs, ) return KeyVaultCertificate._from_certificate_bundle(certificate_bundle=bundle) @@ -592,8 +652,10 @@ def list_deleted_certificates( return self._client.get_deleted_certificates( maxresults=max_page_size, - cls=lambda objs: [DeletedCertificate._from_deleted_certificate_item(x) for x in objs], - **kwargs + cls=lambda objs: [ + DeletedCertificate._from_deleted_certificate_item(x) for x in objs + ], + **kwargs, ) @distributed_trace @@ -634,8 +696,10 @@ def list_properties_of_certificates( return self._client.get_certificates( maxresults=max_page_size, - cls=lambda objs: [CertificateProperties._from_certificate_item(x) for x in objs], - **kwargs + cls=lambda objs: [ + CertificateProperties._from_certificate_item(x) for x in objs + ], + **kwargs, ) @distributed_trace @@ -665,12 +729,16 @@ def list_properties_of_certificate_versions( return self._client.get_certificate_versions( certificate_name=certificate_name, maxresults=max_page_size, - cls=lambda objs: [CertificateProperties._from_certificate_item(x) for x in objs], - **kwargs + cls=lambda objs: [ + CertificateProperties._from_certificate_item(x) for x in objs + ], + **kwargs, ) @distributed_trace_async - async def set_contacts(self, contacts: List[CertificateContact], **kwargs: Any) -> List[CertificateContact]: + async def set_contacts( + self, contacts: List[CertificateContact], **kwargs: Any + ) -> List[CertificateContact]: """Sets the certificate contacts for the key vault. Requires certificates/managecontacts permission. :param contacts: The contact list for the vault certificates. @@ -690,11 +758,14 @@ async def set_contacts(self, contacts: List[CertificateContact], **kwargs: Any) :dedent: 8 """ new_contacts = await self._client.set_certificate_contacts( - contacts=self._models.Contacts(contact_list=[c._to_certificate_contacts_item() for c in contacts]), - **kwargs + contacts=self._models.Contacts( + contact_list=[c._to_certificate_contacts_item() for c in contacts] + ), + **kwargs, ) return [ - CertificateContact._from_certificate_contacts_item(contact_item=item) for item in new_contacts.contact_list + CertificateContact._from_certificate_contacts_item(contact_item=item) + for item in new_contacts.contact_list ] @distributed_trace_async @@ -714,9 +785,11 @@ async def get_contacts(self, **kwargs: Any) -> List[CertificateContact]: :caption: Get contacts :dedent: 8 """ - contacts = await self._client.get_certificate_contacts( **kwargs - ) - return [CertificateContact._from_certificate_contacts_item(contact_item=item) for item in contacts.contact_list] + contacts = await self._client.get_certificate_contacts(**kwargs) + return [ + CertificateContact._from_certificate_contacts_item(contact_item=item) + for item in contacts.contact_list + ] @distributed_trace_async async def delete_contacts(self, **kwargs: Any) -> List[CertificateContact]: @@ -735,13 +808,16 @@ async def delete_contacts(self, **kwargs: Any) -> List[CertificateContact]: :caption: Delete contacts :dedent: 8 """ - contacts = await self._client.delete_certificate_contacts( - **kwargs - ) - return [CertificateContact._from_certificate_contacts_item(contact_item=item) for item in contacts.contact_list] + contacts = await self._client.delete_certificate_contacts(**kwargs) + return [ + CertificateContact._from_certificate_contacts_item(contact_item=item) + for item in contacts.contact_list + ] @distributed_trace_async - async def get_certificate_operation(self, certificate_name: str, **kwargs: Any) -> CertificateOperation: + async def get_certificate_operation( + self, certificate_name: str, **kwargs: Any + ) -> CertificateOperation: """Gets the creation operation of a certificate. Requires the certificates/get permission. :param str certificate_name: The name of the certificate. @@ -756,10 +832,14 @@ async def get_certificate_operation(self, certificate_name: str, **kwargs: Any) bundle = await self._client.get_certificate_operation( certificate_name=certificate_name, **kwargs ) - return CertificateOperation._from_certificate_operation_bundle(certificate_operation_bundle=bundle) + return CertificateOperation._from_certificate_operation_bundle( + certificate_operation_bundle=bundle + ) @distributed_trace_async - async def delete_certificate_operation(self, certificate_name: str, **kwargs: Any) -> CertificateOperation: + async def delete_certificate_operation( + self, certificate_name: str, **kwargs: Any + ) -> CertificateOperation: """Deletes and stops the creation operation for a specific certificate. Requires the certificates/update permission. @@ -775,10 +855,14 @@ async def delete_certificate_operation(self, certificate_name: str, **kwargs: An bundle = await self._client.delete_certificate_operation( certificate_name=certificate_name, **kwargs ) - return CertificateOperation._from_certificate_operation_bundle(certificate_operation_bundle=bundle) + return CertificateOperation._from_certificate_operation_bundle( + certificate_operation_bundle=bundle + ) @distributed_trace_async - async def cancel_certificate_operation(self, certificate_name: str, **kwargs: Any) -> CertificateOperation: + async def cancel_certificate_operation( + self, certificate_name: str, **kwargs: Any + ) -> CertificateOperation: """Cancels an in-progress certificate operation. Requires the certificates/update permission. :param str certificate_name: The name of the certificate. @@ -790,10 +874,14 @@ async def cancel_certificate_operation(self, certificate_name: str, **kwargs: An """ bundle = await self._client.update_certificate_operation( certificate_name=certificate_name, - certificate_operation=self._models.CertificateOperationUpdateParameter(cancellation_requested=True), - **kwargs + certificate_operation=self._models.CertificateOperationUpdateParameter( + cancellation_requested=True + ), + **kwargs, + ) + return CertificateOperation._from_certificate_operation_bundle( + certificate_operation_bundle=bundle ) - return CertificateOperation._from_certificate_operation_bundle(certificate_operation_bundle=bundle) @distributed_trace_async async def merge_certificate( @@ -832,13 +920,13 @@ async def merge_certificate( attributes = None parameters = self._models.CertificateMergeParameters( - x509_certificates=x509_certificates, certificate_attributes=attributes, tags=tags + x509_certificates=x509_certificates, + certificate_attributes=attributes, + tags=tags, ) bundle = await self._client.merge_certificate( - certificate_name=certificate_name, - parameters=parameters, - **kwargs + certificate_name=certificate_name, parameters=parameters, **kwargs ) return KeyVaultCertificate._from_certificate_bundle(certificate_bundle=bundle) @@ -908,7 +996,9 @@ async def create_issuer( """ if account_id or password: - issuer_credentials = self._models.IssuerCredentials(account_id=account_id, password=password) + issuer_credentials = self._models.IssuerCredentials( + account_id=account_id, password=password + ) else: issuer_credentials = None if admin_contacts: @@ -924,7 +1014,9 @@ async def create_issuer( else: admin_details = None if organization_id or admin_details: - organization_details = self._models.OrganizationDetails(id=organization_id, admin_details=admin_details) + organization_details = self._models.OrganizationDetails( + id=organization_id, admin_details=admin_details + ) else: organization_details = None if enabled is not None: @@ -977,7 +1069,9 @@ async def update_issuer( """ if account_id or password: - issuer_credentials = self._models.IssuerCredentials(account_id=account_id, password=password) + issuer_credentials = self._models.IssuerCredentials( + account_id=account_id, password=password + ) else: issuer_credentials = None if admin_contacts: @@ -993,7 +1087,9 @@ async def update_issuer( else: admin_details = None if organization_id or admin_details: - organization_details = self._models.OrganizationDetails(id=organization_id, admin_details=admin_details) + organization_details = self._models.OrganizationDetails( + id=organization_id, admin_details=admin_details + ) else: organization_details = None if enabled is not None: @@ -1040,7 +1136,9 @@ async def delete_issuer(self, issuer_name: str, **kwargs: Any) -> CertificateIss return CertificateIssuer._from_issuer_bundle(issuer_bundle=issuer_bundle) @distributed_trace - def list_properties_of_issuers(self, **kwargs: Any) -> AsyncItemPaged[IssuerProperties]: + def list_properties_of_issuers( + self, **kwargs: Any + ) -> AsyncItemPaged[IssuerProperties]: """Lists properties of the certificate issuers for the key vault. Requires the certificates/manageissuers/getissuers permission. @@ -1062,7 +1160,7 @@ def list_properties_of_issuers(self, **kwargs: Any) -> AsyncItemPaged[IssuerProp return self._client.get_certificate_issuers( maxresults=max_page_size, cls=lambda objs: [IssuerProperties._from_issuer_item(x) for x in objs], - **kwargs + **kwargs, ) async def __aenter__(self) -> "CertificateClient": diff --git a/sdk/keyvault/azure-keyvault-certificates/tests/conftest.py b/sdk/keyvault/azure-keyvault-certificates/tests/conftest.py index 3a6b6a4f0dd5..2a727857b7bd 100644 --- a/sdk/keyvault/azure-keyvault-certificates/tests/conftest.py +++ b/sdk/keyvault/azure-keyvault-certificates/tests/conftest.py @@ -82,6 +82,6 @@ def immediate_return(_): @pytest.fixture(scope="session") def event_loop(request): - loop = asyncio.get_event_loop() + loop = asyncio.new_event_loop() yield loop loop.close() diff --git a/sdk/keyvault/azure-keyvault-certificates/tests/test_certificates_client.py b/sdk/keyvault/azure-keyvault-certificates/tests/test_certificates_client.py index 74932f3cffa8..18819d705100 100644 --- a/sdk/keyvault/azure-keyvault-certificates/tests/test_certificates_client.py +++ b/sdk/keyvault/azure-keyvault-certificates/tests/test_certificates_client.py @@ -125,6 +125,27 @@ def _validate_sans(self, a, b): assert set(a.san_emails) == set(b.san_emails) if a.san_user_principal_names: assert set(a.san_user_principal_names) == set(b.san_user_principal_names) + if a.san_uris: + assert set(a.san_uris) == set(b.san_uris) + if a.san_ip_addresses: + assert set(a.san_ip_addresses) == set(b.san_ip_addresses) + + def test_validate_sans_with_uris_and_ip_addresses(self): + "`Unit test: ensures _validate_sans exercises the new san_uris and san_ip_addresses paths." + policy_a = CertificatePolicy( + issuer_name=WellKnownIssuerNames.self, + subject="CN=example.com", + san_uris=["urn:example:one", "https://example.com/service"], + san_ip_addresses=["192.0.2.1", "2001:db8::1"], + ) + policy_b = CertificatePolicy( + issuer_name=WellKnownIssuerNames.self, + subject="CN=example.com", + san_uris=["https://example.com/service", "urn:example:one"], + san_ip_addresses=["2001:db8::1", "192.0.2.1"], + ) + # _validate_sans compares sets, so ordering differences should not matter + self._validate_sans(policy_a, policy_b) def _validate_lifetime_actions(self, a, b): assert len(a) == len(b) diff --git a/sdk/keyvault/azure-keyvault-certificates/tests/test_certificates_client_async.py b/sdk/keyvault/azure-keyvault-certificates/tests/test_certificates_client_async.py index b7265a59b4f7..9e2dfe9026f3 100644 --- a/sdk/keyvault/azure-keyvault-certificates/tests/test_certificates_client_async.py +++ b/sdk/keyvault/azure-keyvault-certificates/tests/test_certificates_client_async.py @@ -119,7 +119,11 @@ def _validate_sans(self, a, b): if a.san_emails: assert set(a.san_emails) == set(b.san_emails) if a.san_user_principal_names: - assert set(a.san_user_principal_names), set(b.san_user_principal_names) + assert set(a.san_user_principal_names) == set(b.san_user_principal_names) + if a.san_uris: + assert set(a.san_uris) == set(b.san_uris) + if a.san_ip_addresses: + assert set(a.san_ip_addresses) == set(b.san_ip_addresses) def _validate_lifetime_actions(self, a, b): assert len(a) == len(b) diff --git a/sdk/keyvault/azure-keyvault-certificates/tsp-location.yaml b/sdk/keyvault/azure-keyvault-certificates/tsp-location.yaml index 82e8d3a7b903..e50f2430d189 100644 --- a/sdk/keyvault/azure-keyvault-certificates/tsp-location.yaml +++ b/sdk/keyvault/azure-keyvault-certificates/tsp-location.yaml @@ -1,5 +1,5 @@ directory: specification/keyvault/Security.KeyVault.Certificates -commit: 9015889a4cae078355b642b3c66d0f18ce41e075 +commit: 48e2c462287288d03adad21e682404d90375462e repo: Azure/azure-rest-api-specs additionalDirectories: - specification/keyvault/Security.KeyVault.Common/