diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/CHANGELOG.md b/sdk/databasewatcher/azure-mgmt-databasewatcher/CHANGELOG.md index d274c20d1aae..c83603428142 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/CHANGELOG.md +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/CHANGELOG.md @@ -1,5 +1,522 @@ # Release History +## 1.0.0 (2025-04-27) + +### Features Added + + - Model `AlertRuleResource` added parameter `kwargs` in method `as_dict` + - Model `AlertRuleResource` added method `deserialize` + - Model `AlertRuleResource` added method `enable_additional_properties_sending` + - Model `AlertRuleResource` added method `from_dict` + - Model `AlertRuleResource` added method `is_xml_model` + - Model `AlertRuleResource` added method `serialize` + - Model `AlertRuleResource` added property `alert_rule_resource_id` + - Model `AlertRuleResource` added property `created_with_properties` + - Model `AlertRuleResource` added property `creation_time` + - Model `AlertRuleResource` added property `provisioning_state` + - Model `AlertRuleResource` added property `alert_rule_template_id` + - Model `AlertRuleResource` added property `alert_rule_template_version` + - Model `AlertRuleResource` added property `additional_properties` + - Model `Datastore` added parameter `kwargs` in method `as_dict` + - Model `Datastore` added method `deserialize` + - Model `Datastore` added method `enable_additional_properties_sending` + - Model `Datastore` added method `from_dict` + - Model `Datastore` added method `is_xml_model` + - Model `Datastore` added method `serialize` + - Model `Datastore` added property `additional_properties` + - Model `ErrorAdditionalInfo` added parameter `kwargs` in method `as_dict` + - Model `ErrorAdditionalInfo` added method `deserialize` + - Model `ErrorAdditionalInfo` added method `enable_additional_properties_sending` + - Model `ErrorAdditionalInfo` added method `from_dict` + - Model `ErrorAdditionalInfo` added method `is_xml_model` + - Model `ErrorAdditionalInfo` added method `serialize` + - Model `ErrorAdditionalInfo` added property `additional_properties` + - Model `ErrorDetail` added parameter `kwargs` in method `as_dict` + - Model `ErrorDetail` added method `deserialize` + - Model `ErrorDetail` added method `enable_additional_properties_sending` + - Model `ErrorDetail` added method `from_dict` + - Model `ErrorDetail` added method `is_xml_model` + - Model `ErrorDetail` added method `serialize` + - Model `ErrorDetail` added property `additional_properties` + - Model `ErrorResponse` added parameter `kwargs` in method `as_dict` + - Model `ErrorResponse` added method `deserialize` + - Model `ErrorResponse` added method `enable_additional_properties_sending` + - Model `ErrorResponse` added method `from_dict` + - Model `ErrorResponse` added method `is_xml_model` + - Model `ErrorResponse` added method `serialize` + - Model `ErrorResponse` added property `additional_properties` + - Model `HealthValidation` added parameter `kwargs` in method `as_dict` + - Model `HealthValidation` added method `deserialize` + - Model `HealthValidation` added method `enable_additional_properties_sending` + - Model `HealthValidation` added method `from_dict` + - Model `HealthValidation` added method `is_xml_model` + - Model `HealthValidation` added method `serialize` + - Model `HealthValidation` added property `start_time` + - Model `HealthValidation` added property `end_time` + - Model `HealthValidation` added property `status` + - Model `HealthValidation` added property `issues` + - Model `HealthValidation` added property `provisioning_state` + - Model `HealthValidation` added property `additional_properties` + - Enum `ManagedServiceIdentityType` added member `SYSTEM_ASSIGNED_USER_ASSIGNED` + - Model `Operation` added parameter `kwargs` in method `as_dict` + - Model `Operation` added method `deserialize` + - Model `Operation` added method `enable_additional_properties_sending` + - Model `Operation` added method `from_dict` + - Model `Operation` added method `is_xml_model` + - Model `Operation` added method `serialize` + - Model `Operation` added property `additional_properties` + - Model `OperationDisplay` added parameter `kwargs` in method `as_dict` + - Model `OperationDisplay` added method `deserialize` + - Model `OperationDisplay` added method `enable_additional_properties_sending` + - Model `OperationDisplay` added method `from_dict` + - Model `OperationDisplay` added method `is_xml_model` + - Model `OperationDisplay` added method `serialize` + - Model `OperationDisplay` added property `additional_properties` + - Model `ProxyResource` added parameter `kwargs` in method `as_dict` + - Model `ProxyResource` added method `deserialize` + - Model `ProxyResource` added method `enable_additional_properties_sending` + - Model `ProxyResource` added method `from_dict` + - Model `ProxyResource` added method `is_xml_model` + - Model `ProxyResource` added method `serialize` + - Model `ProxyResource` added property `additional_properties` + - Model `Resource` added parameter `kwargs` in method `as_dict` + - Model `Resource` added method `deserialize` + - Model `Resource` added method `enable_additional_properties_sending` + - Model `Resource` added method `from_dict` + - Model `Resource` added method `is_xml_model` + - Model `Resource` added method `serialize` + - Model `Resource` added property `additional_properties` + - Model `SharedPrivateLinkResource` added parameter `kwargs` in method `as_dict` + - Model `SharedPrivateLinkResource` added method `deserialize` + - Model `SharedPrivateLinkResource` added method `enable_additional_properties_sending` + - Model `SharedPrivateLinkResource` added method `from_dict` + - Model `SharedPrivateLinkResource` added method `is_xml_model` + - Model `SharedPrivateLinkResource` added method `serialize` + - Model `SharedPrivateLinkResource` added property `private_link_resource_id` + - Model `SharedPrivateLinkResource` added property `group_id` + - Model `SharedPrivateLinkResource` added property `request_message` + - Model `SharedPrivateLinkResource` added property `dns_zone` + - Model `SharedPrivateLinkResource` added property `status` + - Model `SharedPrivateLinkResource` added property `provisioning_state` + - Model `SharedPrivateLinkResource` added property `additional_properties` + - Model `SqlDbElasticPoolTargetProperties` added parameter `kwargs` in method `as_dict` + - Model `SqlDbElasticPoolTargetProperties` added method `deserialize` + - Model `SqlDbElasticPoolTargetProperties` added method `enable_additional_properties_sending` + - Model `SqlDbElasticPoolTargetProperties` added method `from_dict` + - Model `SqlDbElasticPoolTargetProperties` added method `is_xml_model` + - Model `SqlDbElasticPoolTargetProperties` added method `serialize` + - Model `SqlDbElasticPoolTargetProperties` added property `additional_properties` + - Model `SqlDbSingleDatabaseTargetProperties` added parameter `kwargs` in method `as_dict` + - Model `SqlDbSingleDatabaseTargetProperties` added method `deserialize` + - Model `SqlDbSingleDatabaseTargetProperties` added method `enable_additional_properties_sending` + - Model `SqlDbSingleDatabaseTargetProperties` added method `from_dict` + - Model `SqlDbSingleDatabaseTargetProperties` added method `is_xml_model` + - Model `SqlDbSingleDatabaseTargetProperties` added method `serialize` + - Model `SqlDbSingleDatabaseTargetProperties` added property `additional_properties` + - Model `SqlMiTargetProperties` added parameter `kwargs` in method `as_dict` + - Model `SqlMiTargetProperties` added method `deserialize` + - Model `SqlMiTargetProperties` added method `enable_additional_properties_sending` + - Model `SqlMiTargetProperties` added method `from_dict` + - Model `SqlMiTargetProperties` added method `is_xml_model` + - Model `SqlMiTargetProperties` added method `serialize` + - Model `SqlMiTargetProperties` added property `additional_properties` + - Model `SystemData` added parameter `kwargs` in method `as_dict` + - Model `SystemData` added method `deserialize` + - Model `SystemData` added method `enable_additional_properties_sending` + - Model `SystemData` added method `from_dict` + - Model `SystemData` added method `is_xml_model` + - Model `SystemData` added method `serialize` + - Model `SystemData` added property `additional_properties` + - Model `Target` added parameter `kwargs` in method `as_dict` + - Model `Target` added method `deserialize` + - Model `Target` added method `enable_additional_properties_sending` + - Model `Target` added method `from_dict` + - Model `Target` added method `is_xml_model` + - Model `Target` added method `serialize` + - Model `Target` added property `target_type` + - Model `Target` added property `target_authentication_type` + - Model `Target` added property `target_vault` + - Model `Target` added property `connection_server_name` + - Model `Target` added property `provisioning_state` + - Model `Target` added property `additional_properties` + - Model `TargetProperties` added parameter `kwargs` in method `as_dict` + - Model `TargetProperties` added method `deserialize` + - Model `TargetProperties` added method `enable_additional_properties_sending` + - Model `TargetProperties` added method `from_dict` + - Model `TargetProperties` added method `is_xml_model` + - Model `TargetProperties` added method `serialize` + - Model `TargetProperties` added property `additional_properties` + - Model `TrackedResource` added parameter `kwargs` in method `as_dict` + - Model `TrackedResource` added method `deserialize` + - Model `TrackedResource` added method `enable_additional_properties_sending` + - Model `TrackedResource` added method `from_dict` + - Model `TrackedResource` added method `is_xml_model` + - Model `TrackedResource` added method `serialize` + - Model `TrackedResource` added property `additional_properties` + - Model `UserAssignedIdentity` added parameter `kwargs` in method `as_dict` + - Model `UserAssignedIdentity` added method `deserialize` + - Model `UserAssignedIdentity` added method `enable_additional_properties_sending` + - Model `UserAssignedIdentity` added method `from_dict` + - Model `UserAssignedIdentity` added method `is_xml_model` + - Model `UserAssignedIdentity` added method `serialize` + - Model `UserAssignedIdentity` added property `additional_properties` + - Model `ValidationIssue` added parameter `kwargs` in method `as_dict` + - Model `ValidationIssue` added method `deserialize` + - Model `ValidationIssue` added method `enable_additional_properties_sending` + - Model `ValidationIssue` added method `from_dict` + - Model `ValidationIssue` added method `is_xml_model` + - Model `ValidationIssue` added method `serialize` + - Model `ValidationIssue` added property `additional_properties` + - Model `VaultSecret` added parameter `kwargs` in method `as_dict` + - Model `VaultSecret` added method `deserialize` + - Model `VaultSecret` added method `enable_additional_properties_sending` + - Model `VaultSecret` added method `from_dict` + - Model `VaultSecret` added method `is_xml_model` + - Model `VaultSecret` added method `serialize` + - Model `VaultSecret` added property `additional_properties` + - Model `Watcher` added parameter `kwargs` in method `as_dict` + - Model `Watcher` added method `deserialize` + - Model `Watcher` added method `enable_additional_properties_sending` + - Model `Watcher` added method `from_dict` + - Model `Watcher` added method `is_xml_model` + - Model `Watcher` added method `serialize` + - Model `Watcher` added property `datastore` + - Model `Watcher` added property `status` + - Model `Watcher` added property `provisioning_state` + - Model `Watcher` added property `default_alert_rule_identity_resource_id` + - Model `Watcher` added property `additional_properties` + - Model `WatcherUpdate` added parameter `kwargs` in method `as_dict` + - Model `WatcherUpdate` added method `deserialize` + - Model `WatcherUpdate` added method `enable_additional_properties_sending` + - Model `WatcherUpdate` added method `from_dict` + - Model `WatcherUpdate` added method `is_xml_model` + - Model `WatcherUpdate` added method `serialize` + - Model `WatcherUpdate` added property `datastore` + - Model `WatcherUpdate` added property `default_alert_rule_identity_resource_id` + - Model `WatcherUpdate` added property `additional_properties` + - Added model `AlertRuleResourceListResult` + - Added model `DatastoreUpdate` + - Added model `HealthValidationListResult` + - Added model `ManagedServiceIdentity` + - Added model `OperationListResult` + - Added model `SharedPrivateLinkResourceListResult` + - Added model `TargetListResult` + - Added model `WatcherListResult` + +### Breaking Changes + + - Deleted or renamed client `DatabaseWatcherMgmtClient` + - Model `AlertRuleResource` deleted or renamed its instance variable `properties` + - Method `AlertRuleResource.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `AlertRuleResource.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `AlertRuleResource.clear` + - Deleted or renamed method `AlertRuleResource.copy` + - Deleted or renamed method `AlertRuleResource.get` + - Deleted or renamed method `AlertRuleResource.items` + - Deleted or renamed method `AlertRuleResource.keys` + - Deleted or renamed method `AlertRuleResource.pop` + - Deleted or renamed method `AlertRuleResource.popitem` + - Deleted or renamed method `AlertRuleResource.setdefault` + - Deleted or renamed method `AlertRuleResource.update` + - Deleted or renamed method `AlertRuleResource.values` + - Method `Datastore.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `Datastore.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `Datastore.clear` + - Deleted or renamed method `Datastore.copy` + - Deleted or renamed method `Datastore.get` + - Deleted or renamed method `Datastore.items` + - Deleted or renamed method `Datastore.keys` + - Deleted or renamed method `Datastore.pop` + - Deleted or renamed method `Datastore.popitem` + - Deleted or renamed method `Datastore.setdefault` + - Deleted or renamed method `Datastore.update` + - Deleted or renamed method `Datastore.values` + - Method `ErrorAdditionalInfo.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `ErrorAdditionalInfo.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `ErrorAdditionalInfo.clear` + - Deleted or renamed method `ErrorAdditionalInfo.copy` + - Deleted or renamed method `ErrorAdditionalInfo.get` + - Deleted or renamed method `ErrorAdditionalInfo.items` + - Deleted or renamed method `ErrorAdditionalInfo.keys` + - Deleted or renamed method `ErrorAdditionalInfo.pop` + - Deleted or renamed method `ErrorAdditionalInfo.popitem` + - Deleted or renamed method `ErrorAdditionalInfo.setdefault` + - Deleted or renamed method `ErrorAdditionalInfo.update` + - Deleted or renamed method `ErrorAdditionalInfo.values` + - Method `ErrorDetail.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `ErrorDetail.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `ErrorDetail.clear` + - Deleted or renamed method `ErrorDetail.copy` + - Deleted or renamed method `ErrorDetail.get` + - Deleted or renamed method `ErrorDetail.items` + - Deleted or renamed method `ErrorDetail.keys` + - Deleted or renamed method `ErrorDetail.pop` + - Deleted or renamed method `ErrorDetail.popitem` + - Deleted or renamed method `ErrorDetail.setdefault` + - Deleted or renamed method `ErrorDetail.update` + - Deleted or renamed method `ErrorDetail.values` + - Method `ErrorResponse.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `ErrorResponse.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `ErrorResponse.clear` + - Deleted or renamed method `ErrorResponse.copy` + - Deleted or renamed method `ErrorResponse.get` + - Deleted or renamed method `ErrorResponse.items` + - Deleted or renamed method `ErrorResponse.keys` + - Deleted or renamed method `ErrorResponse.pop` + - Deleted or renamed method `ErrorResponse.popitem` + - Deleted or renamed method `ErrorResponse.setdefault` + - Deleted or renamed method `ErrorResponse.update` + - Deleted or renamed method `ErrorResponse.values` + - Model `HealthValidation` deleted or renamed its instance variable `properties` + - Method `HealthValidation.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `HealthValidation.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `HealthValidation.clear` + - Deleted or renamed method `HealthValidation.copy` + - Deleted or renamed method `HealthValidation.get` + - Deleted or renamed method `HealthValidation.items` + - Deleted or renamed method `HealthValidation.keys` + - Deleted or renamed method `HealthValidation.pop` + - Deleted or renamed method `HealthValidation.popitem` + - Deleted or renamed method `HealthValidation.setdefault` + - Deleted or renamed method `HealthValidation.update` + - Deleted or renamed method `HealthValidation.values` + - Deleted or renamed enum value `ManagedServiceIdentityType.SYSTEM_AND_USER_ASSIGNED` + - Method `Operation.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `Operation.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `Operation.clear` + - Deleted or renamed method `Operation.copy` + - Deleted or renamed method `Operation.get` + - Deleted or renamed method `Operation.items` + - Deleted or renamed method `Operation.keys` + - Deleted or renamed method `Operation.pop` + - Deleted or renamed method `Operation.popitem` + - Deleted or renamed method `Operation.setdefault` + - Deleted or renamed method `Operation.update` + - Deleted or renamed method `Operation.values` + - Method `OperationDisplay.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `OperationDisplay.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `OperationDisplay.clear` + - Deleted or renamed method `OperationDisplay.copy` + - Deleted or renamed method `OperationDisplay.get` + - Deleted or renamed method `OperationDisplay.items` + - Deleted or renamed method `OperationDisplay.keys` + - Deleted or renamed method `OperationDisplay.pop` + - Deleted or renamed method `OperationDisplay.popitem` + - Deleted or renamed method `OperationDisplay.setdefault` + - Deleted or renamed method `OperationDisplay.update` + - Deleted or renamed method `OperationDisplay.values` + - Method `ProxyResource.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `ProxyResource.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `ProxyResource.clear` + - Deleted or renamed method `ProxyResource.copy` + - Deleted or renamed method `ProxyResource.get` + - Deleted or renamed method `ProxyResource.items` + - Deleted or renamed method `ProxyResource.keys` + - Deleted or renamed method `ProxyResource.pop` + - Deleted or renamed method `ProxyResource.popitem` + - Deleted or renamed method `ProxyResource.setdefault` + - Deleted or renamed method `ProxyResource.update` + - Deleted or renamed method `ProxyResource.values` + - Method `Resource.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `Resource.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `Resource.clear` + - Deleted or renamed method `Resource.copy` + - Deleted or renamed method `Resource.get` + - Deleted or renamed method `Resource.items` + - Deleted or renamed method `Resource.keys` + - Deleted or renamed method `Resource.pop` + - Deleted or renamed method `Resource.popitem` + - Deleted or renamed method `Resource.setdefault` + - Deleted or renamed method `Resource.update` + - Deleted or renamed method `Resource.values` + - Model `SharedPrivateLinkResource` deleted or renamed its instance variable `properties` + - Method `SharedPrivateLinkResource.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `SharedPrivateLinkResource.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `SharedPrivateLinkResource.clear` + - Deleted or renamed method `SharedPrivateLinkResource.copy` + - Deleted or renamed method `SharedPrivateLinkResource.get` + - Deleted or renamed method `SharedPrivateLinkResource.items` + - Deleted or renamed method `SharedPrivateLinkResource.keys` + - Deleted or renamed method `SharedPrivateLinkResource.pop` + - Deleted or renamed method `SharedPrivateLinkResource.popitem` + - Deleted or renamed method `SharedPrivateLinkResource.setdefault` + - Deleted or renamed method `SharedPrivateLinkResource.update` + - Deleted or renamed method `SharedPrivateLinkResource.values` + - Method `SqlDbElasticPoolTargetProperties.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `SqlDbElasticPoolTargetProperties.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `SqlDbElasticPoolTargetProperties.clear` + - Deleted or renamed method `SqlDbElasticPoolTargetProperties.copy` + - Deleted or renamed method `SqlDbElasticPoolTargetProperties.get` + - Deleted or renamed method `SqlDbElasticPoolTargetProperties.items` + - Deleted or renamed method `SqlDbElasticPoolTargetProperties.keys` + - Deleted or renamed method `SqlDbElasticPoolTargetProperties.pop` + - Deleted or renamed method `SqlDbElasticPoolTargetProperties.popitem` + - Deleted or renamed method `SqlDbElasticPoolTargetProperties.setdefault` + - Deleted or renamed method `SqlDbElasticPoolTargetProperties.update` + - Deleted or renamed method `SqlDbElasticPoolTargetProperties.values` + - Method `SqlDbSingleDatabaseTargetProperties.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `SqlDbSingleDatabaseTargetProperties.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `SqlDbSingleDatabaseTargetProperties.clear` + - Deleted or renamed method `SqlDbSingleDatabaseTargetProperties.copy` + - Deleted or renamed method `SqlDbSingleDatabaseTargetProperties.get` + - Deleted or renamed method `SqlDbSingleDatabaseTargetProperties.items` + - Deleted or renamed method `SqlDbSingleDatabaseTargetProperties.keys` + - Deleted or renamed method `SqlDbSingleDatabaseTargetProperties.pop` + - Deleted or renamed method `SqlDbSingleDatabaseTargetProperties.popitem` + - Deleted or renamed method `SqlDbSingleDatabaseTargetProperties.setdefault` + - Deleted or renamed method `SqlDbSingleDatabaseTargetProperties.update` + - Deleted or renamed method `SqlDbSingleDatabaseTargetProperties.values` + - Method `SqlMiTargetProperties.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `SqlMiTargetProperties.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `SqlMiTargetProperties.clear` + - Deleted or renamed method `SqlMiTargetProperties.copy` + - Deleted or renamed method `SqlMiTargetProperties.get` + - Deleted or renamed method `SqlMiTargetProperties.items` + - Deleted or renamed method `SqlMiTargetProperties.keys` + - Deleted or renamed method `SqlMiTargetProperties.pop` + - Deleted or renamed method `SqlMiTargetProperties.popitem` + - Deleted or renamed method `SqlMiTargetProperties.setdefault` + - Deleted or renamed method `SqlMiTargetProperties.update` + - Deleted or renamed method `SqlMiTargetProperties.values` + - Method `SystemData.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `SystemData.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `SystemData.clear` + - Deleted or renamed method `SystemData.copy` + - Deleted or renamed method `SystemData.get` + - Deleted or renamed method `SystemData.items` + - Deleted or renamed method `SystemData.keys` + - Deleted or renamed method `SystemData.pop` + - Deleted or renamed method `SystemData.popitem` + - Deleted or renamed method `SystemData.setdefault` + - Deleted or renamed method `SystemData.update` + - Deleted or renamed method `SystemData.values` + - Model `Target` deleted or renamed its instance variable `properties` + - Method `Target.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `Target.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `Target.clear` + - Deleted or renamed method `Target.copy` + - Deleted or renamed method `Target.get` + - Deleted or renamed method `Target.items` + - Deleted or renamed method `Target.keys` + - Deleted or renamed method `Target.pop` + - Deleted or renamed method `Target.popitem` + - Deleted or renamed method `Target.setdefault` + - Deleted or renamed method `Target.update` + - Deleted or renamed method `Target.values` + - Method `TargetProperties.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `TargetProperties.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `TargetProperties.clear` + - Deleted or renamed method `TargetProperties.copy` + - Deleted or renamed method `TargetProperties.get` + - Deleted or renamed method `TargetProperties.items` + - Deleted or renamed method `TargetProperties.keys` + - Deleted or renamed method `TargetProperties.pop` + - Deleted or renamed method `TargetProperties.popitem` + - Deleted or renamed method `TargetProperties.setdefault` + - Deleted or renamed method `TargetProperties.update` + - Deleted or renamed method `TargetProperties.values` + - Method `TrackedResource.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `TrackedResource.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `TrackedResource.clear` + - Deleted or renamed method `TrackedResource.copy` + - Deleted or renamed method `TrackedResource.get` + - Deleted or renamed method `TrackedResource.items` + - Deleted or renamed method `TrackedResource.keys` + - Deleted or renamed method `TrackedResource.pop` + - Deleted or renamed method `TrackedResource.popitem` + - Deleted or renamed method `TrackedResource.setdefault` + - Deleted or renamed method `TrackedResource.update` + - Deleted or renamed method `TrackedResource.values` + - Method `UserAssignedIdentity.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `UserAssignedIdentity.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `UserAssignedIdentity.clear` + - Deleted or renamed method `UserAssignedIdentity.copy` + - Deleted or renamed method `UserAssignedIdentity.get` + - Deleted or renamed method `UserAssignedIdentity.items` + - Deleted or renamed method `UserAssignedIdentity.keys` + - Deleted or renamed method `UserAssignedIdentity.pop` + - Deleted or renamed method `UserAssignedIdentity.popitem` + - Deleted or renamed method `UserAssignedIdentity.setdefault` + - Deleted or renamed method `UserAssignedIdentity.update` + - Deleted or renamed method `UserAssignedIdentity.values` + - Method `ValidationIssue.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `ValidationIssue.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `ValidationIssue.clear` + - Deleted or renamed method `ValidationIssue.copy` + - Deleted or renamed method `ValidationIssue.get` + - Deleted or renamed method `ValidationIssue.items` + - Deleted or renamed method `ValidationIssue.keys` + - Deleted or renamed method `ValidationIssue.pop` + - Deleted or renamed method `ValidationIssue.popitem` + - Deleted or renamed method `ValidationIssue.setdefault` + - Deleted or renamed method `ValidationIssue.update` + - Deleted or renamed method `ValidationIssue.values` + - Method `VaultSecret.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `VaultSecret.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `VaultSecret.clear` + - Deleted or renamed method `VaultSecret.copy` + - Deleted or renamed method `VaultSecret.get` + - Deleted or renamed method `VaultSecret.items` + - Deleted or renamed method `VaultSecret.keys` + - Deleted or renamed method `VaultSecret.pop` + - Deleted or renamed method `VaultSecret.popitem` + - Deleted or renamed method `VaultSecret.setdefault` + - Deleted or renamed method `VaultSecret.update` + - Deleted or renamed method `VaultSecret.values` + - Model `Watcher` deleted or renamed its instance variable `properties` + - Method `Watcher.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `Watcher.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `Watcher.clear` + - Deleted or renamed method `Watcher.copy` + - Deleted or renamed method `Watcher.get` + - Deleted or renamed method `Watcher.items` + - Deleted or renamed method `Watcher.keys` + - Deleted or renamed method `Watcher.pop` + - Deleted or renamed method `Watcher.popitem` + - Deleted or renamed method `Watcher.setdefault` + - Deleted or renamed method `Watcher.update` + - Deleted or renamed method `Watcher.values` + - Model `WatcherUpdate` deleted or renamed its instance variable `properties` + - Method `WatcherUpdate.as_dict` inserted a `positional_or_keyword` parameter `keep_readonly` + - Method `WatcherUpdate.as_dict` inserted a `positional_or_keyword` parameter `key_transformer` + - Deleted or renamed method `WatcherUpdate.clear` + - Deleted or renamed method `WatcherUpdate.copy` + - Deleted or renamed method `WatcherUpdate.get` + - Deleted or renamed method `WatcherUpdate.items` + - Deleted or renamed method `WatcherUpdate.keys` + - Deleted or renamed method `WatcherUpdate.pop` + - Deleted or renamed method `WatcherUpdate.popitem` + - Deleted or renamed method `WatcherUpdate.setdefault` + - Deleted or renamed method `WatcherUpdate.update` + - Deleted or renamed method `WatcherUpdate.values` + - Deleted or renamed model `AlertRuleResourceProperties` + - Deleted or renamed model `HealthValidationProperties` + - Deleted or renamed model `ManagedServiceIdentityV4` + - Deleted or renamed model `SharedPrivateLinkResourceProperties` + - Deleted or renamed model `WatcherProperties` + - Deleted or renamed model `WatcherUpdateProperties` + - `AlertRuleResource.__init__` had all overloads removed + - `Datastore.__init__` had all overloads removed + - `ErrorResponse.__init__` had all overloads removed + - `HealthValidation.__init__` had all overloads removed + - `Operation.__init__` had all overloads removed + - `SharedPrivateLinkResource.__init__` had all overloads removed + - `SqlDbElasticPoolTargetProperties.__init__` had all overloads removed + - `SqlDbSingleDatabaseTargetProperties.__init__` had all overloads removed + - `SqlMiTargetProperties.__init__` had all overloads removed + - `SystemData.__init__` had all overloads removed + - `Target.__init__` had all overloads removed + - `TargetProperties.__init__` had all overloads removed + - `TrackedResource.__init__` had all overloads removed + - `VaultSecret.__init__` had all overloads removed + - `Watcher.__init__` had all overloads removed + - `WatcherUpdate.__init__` had all overloads removed + - `AlertRuleResourcesOperations.create_or_update` had an overload `def create_or_update(self: None, resource_group_name: str, watcher_name: str, alert_rule_resource_name: str, resource: JSON, content_type: str)` removed + - `SharedPrivateLinkResourcesOperations.begin_create` had an overload `def begin_create(self: None, resource_group_name: str, watcher_name: str, shared_private_link_resource_name: str, resource: JSON, content_type: str)` removed + - `TargetsOperations.create_or_update` had an overload `def create_or_update(self: None, resource_group_name: str, watcher_name: str, target_name: str, resource: JSON, content_type: str)` removed + - `WatchersOperations.begin_create_or_update` had an overload `def begin_create_or_update(self: None, resource_group_name: str, watcher_name: str, resource: JSON, content_type: str)` removed + - `WatchersOperations.begin_update` had an overload `def begin_update(self: None, resource_group_name: str, watcher_name: str, properties: JSON, content_type: str)` removed + ## 1.0.0b1 (2025-02-28) ### Other Changes diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/README.md b/sdk/databasewatcher/azure-mgmt-databasewatcher/README.md index f5ae279d2056..0ed600e0eca9 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/README.md +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/README.md @@ -1,7 +1,7 @@ # Microsoft Azure SDK for Python This is the Microsoft Azure Databasewatcher Management Client Library. -This package has been tested with Python 3.8+. +This package has been tested with Python 3.9+. For a more complete view of Azure libraries, see the [azure sdk python release](https://aka.ms/azsdk/python/all). ## _Disclaimer_ @@ -12,7 +12,7 @@ _Azure SDK Python packages support for Python 2.7 has ended 01 January 2022. For ### Prerequisites -- Python 3.8+ is required to use this package. +- Python 3.9+ is required to use this package. - [Azure subscription](https://azure.microsoft.com/free/) ### Install the package @@ -24,7 +24,7 @@ pip install azure-identity ### Authentication -By default, [Azure Active Directory](https://aka.ms/awps/aad) token authentication depends on correct configure of following environment variables. +By default, [Azure Active Directory](https://aka.ms/awps/aad) token authentication depends on correct configuration of the following environment variables. - `AZURE_CLIENT_ID` for Azure client ID. - `AZURE_TENANT_ID` for Azure tenant ID. diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/_meta.json b/sdk/databasewatcher/azure-mgmt-databasewatcher/_meta.json index da0476bfcbef..5f6dd7f07966 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/_meta.json +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/_meta.json @@ -1,6 +1,13 @@ { - "commit": "07da438f8dc690946b39511467744ed889434de5", + "commit": "c908490d3d2b6fdd1a5dfa108a0f47183e4c06e0", "repository_url": "https://github.com/Azure/azure-rest-api-specs", "typespec_src": "specification/databasewatcher/DatabaseWatcher.Management", - "@azure-tools/typespec-python": "0.38.2" + "@azure-tools/typespec-python": "0.38.2", + "autorest": "3.10.2", + "use": [ + "@autorest/python@6.34.1", + "@autorest/modelerfour@4.27.0" + ], + "autorest_command": "autorest specification/databasewatcher/resource-manager/readme.md --generate-sample=True --generate-test=True --include-x-ms-examples-original-file=True --python --python-sdks-folder=/mnt/vss/_work/1/s/azure-sdk-for-python/sdk --use=@autorest/python@6.34.1 --use=@autorest/modelerfour@4.27.0 --version=3.10.2 --version-tolerant=False", + "readme": "specification/databasewatcher/resource-manager/readme.md" } \ No newline at end of file diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/__init__.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/__init__.py index 1341c5f1352d..de1fb9cbf3ba 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/__init__.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/__init__.py @@ -2,7 +2,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- # pylint: disable=wrong-import-position @@ -12,7 +12,7 @@ if TYPE_CHECKING: from ._patch import * # pylint: disable=unused-wildcard-import -from ._client import DatabaseWatcherMgmtClient # type: ignore +from ._microsoft_database_watcher import MicrosoftDatabaseWatcher # type: ignore from ._version import VERSION __version__ = VERSION @@ -25,7 +25,7 @@ from ._patch import patch_sdk as _patch_sdk __all__ = [ - "DatabaseWatcherMgmtClient", + "MicrosoftDatabaseWatcher", ] __all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_configuration.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_configuration.py index 12aea8cc658e..dd3b35f1f9bc 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_configuration.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_configuration.py @@ -2,7 +2,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- @@ -17,30 +17,22 @@ from azure.core.credentials import TokenCredential -class DatabaseWatcherMgmtClientConfiguration: # pylint: disable=too-many-instance-attributes - """Configuration for DatabaseWatcherMgmtClient. +class MicrosoftDatabaseWatcherConfiguration: # pylint: disable=too-many-instance-attributes + """Configuration for MicrosoftDatabaseWatcher. Note that all parameters used to create this instance are saved as instance attributes. - :param credential: Credential used to authenticate requests to the service. Required. + :param credential: Credential needed for the client to connect to Azure. Required. :type credential: ~azure.core.credentials.TokenCredential :param subscription_id: The ID of the target subscription. The value must be an UUID. Required. :type subscription_id: str - :param base_url: Service host. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: The API version to use for this operation. Default value is "2025-01-02". - Note that overriding this default value may result in unsupported behavior. + :keyword api_version: Api Version. Default value is "2025-01-02". Note that overriding this + default value may result in unsupported behavior. :paramtype api_version: str """ - def __init__( - self, - credential: "TokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: + def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: api_version: str = kwargs.pop("api_version", "2025-01-02") if credential is None: @@ -50,7 +42,6 @@ def __init__( self.credential = credential self.subscription_id = subscription_id - self.base_url = base_url self.api_version = api_version self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) kwargs.setdefault("sdk_moniker", "mgmt-databasewatcher/{}".format(VERSION)) diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_client.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_microsoft_database_watcher.py similarity index 76% rename from sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_client.py rename to sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_microsoft_database_watcher.py index 0876b3ee3254..37eb92b3a404 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_client.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_microsoft_database_watcher.py @@ -2,21 +2,24 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from copy import deepcopy -from typing import Any, TYPE_CHECKING +from typing import Any, Optional, TYPE_CHECKING, cast from typing_extensions import Self from azure.core.pipeline import policies from azure.core.rest import HttpRequest, HttpResponse +from azure.core.settings import settings from azure.mgmt.core import ARMPipelineClient from azure.mgmt.core.policies import ARMAutoResourceProviderRegistrationPolicy +from azure.mgmt.core.tools import get_arm_endpoints -from ._configuration import DatabaseWatcherMgmtClientConfiguration -from ._serialization import Deserializer, Serializer +from . import models as _models +from ._configuration import MicrosoftDatabaseWatcherConfiguration +from ._utils.serialization import Deserializer, Serializer from .operations import ( AlertRuleResourcesOperations, HealthValidationsOperations, @@ -30,8 +33,8 @@ from azure.core.credentials import TokenCredential -class DatabaseWatcherMgmtClient: - """DatabaseWatcherMgmtClient. +class MicrosoftDatabaseWatcher: + """MicrosoftDatabaseWatcher. :ivar operations: Operations operations :vartype operations: azure.mgmt.databasewatcher.operations.Operations @@ -42,35 +45,36 @@ class DatabaseWatcherMgmtClient: azure.mgmt.databasewatcher.operations.AlertRuleResourcesOperations :ivar health_validations: HealthValidationsOperations operations :vartype health_validations: azure.mgmt.databasewatcher.operations.HealthValidationsOperations - :ivar targets: TargetsOperations operations - :vartype targets: azure.mgmt.databasewatcher.operations.TargetsOperations :ivar shared_private_link_resources: SharedPrivateLinkResourcesOperations operations :vartype shared_private_link_resources: azure.mgmt.databasewatcher.operations.SharedPrivateLinkResourcesOperations - :param credential: Credential used to authenticate requests to the service. Required. + :ivar targets: TargetsOperations operations + :vartype targets: azure.mgmt.databasewatcher.operations.TargetsOperations + :param credential: Credential needed for the client to connect to Azure. Required. :type credential: ~azure.core.credentials.TokenCredential :param subscription_id: The ID of the target subscription. The value must be an UUID. Required. :type subscription_id: str - :param base_url: Service host. Default value is "https://management.azure.com". + :param base_url: Service URL. Default value is None. :type base_url: str - :keyword api_version: The API version to use for this operation. Default value is "2025-01-02". - Note that overriding this default value may result in unsupported behavior. + :keyword api_version: Api Version. Default value is "2025-01-02". Note that overriding this + default value may result in unsupported behavior. :paramtype api_version: str :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. """ def __init__( - self, - credential: "TokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any + self, credential: "TokenCredential", subscription_id: str, base_url: Optional[str] = None, **kwargs: Any ) -> None: - _endpoint = "{endpoint}" - self._config = DatabaseWatcherMgmtClientConfiguration( - credential=credential, subscription_id=subscription_id, base_url=base_url, **kwargs + _cloud = kwargs.pop("cloud_setting", None) or settings.current.azure_cloud # type: ignore + _endpoints = get_arm_endpoints(_cloud) + if not base_url: + base_url = _endpoints["resource_manager"] + credential_scopes = kwargs.pop("credential_scopes", _endpoints["credential_scopes"]) + self._config = MicrosoftDatabaseWatcherConfiguration( + credential=credential, subscription_id=subscription_id, credential_scopes=credential_scopes, **kwargs ) + _policies = kwargs.pop("policies", None) if _policies is None: _policies = [ @@ -89,10 +93,11 @@ def __init__( policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, self._config.http_logging_policy, ] - self._client: ARMPipelineClient = ARMPipelineClient(base_url=_endpoint, policies=_policies, **kwargs) + self._client: ARMPipelineClient = ARMPipelineClient(base_url=cast(str, base_url), policies=_policies, **kwargs) - self._serialize = Serializer() - self._deserialize = Deserializer() + client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} + self._serialize = Serializer(client_models) + self._deserialize = Deserializer(client_models) self._serialize.client_side_validation = False self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) self.watchers = WatchersOperations(self._client, self._config, self._serialize, self._deserialize) @@ -102,18 +107,18 @@ def __init__( self.health_validations = HealthValidationsOperations( self._client, self._config, self._serialize, self._deserialize ) - self.targets = TargetsOperations(self._client, self._config, self._serialize, self._deserialize) self.shared_private_link_resources = SharedPrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) + self.targets = TargetsOperations(self._client, self._config, self._serialize, self._deserialize) - def send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse: + def _send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest >>> request = HttpRequest("GET", "https://www.example.org/") - >>> response = client.send_request(request) + >>> response = client._send_request(request) For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request @@ -126,11 +131,7 @@ def send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: """ request_copy = deepcopy(request) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments) + request_copy.url = self._client.format_url(request_copy.url) return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore def close(self) -> None: diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_model_base.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_model_base.py deleted file mode 100644 index 3072ee252ed9..000000000000 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_model_base.py +++ /dev/null @@ -1,1235 +0,0 @@ -# pylint: disable=too-many-lines -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for -# license information. -# -------------------------------------------------------------------------- -# pylint: disable=protected-access, broad-except - -import copy -import calendar -import decimal -import functools -import sys -import logging -import base64 -import re -import typing -import enum -import email.utils -from datetime import datetime, date, time, timedelta, timezone -from json import JSONEncoder -import xml.etree.ElementTree as ET -from typing_extensions import Self -import isodate -from azure.core.exceptions import DeserializationError -from azure.core import CaseInsensitiveEnumMeta -from azure.core.pipeline import PipelineResponse -from azure.core.serialization import _Null - -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping - -_LOGGER = logging.getLogger(__name__) - -__all__ = ["SdkJSONEncoder", "Model", "rest_field", "rest_discriminator"] - -TZ_UTC = timezone.utc -_T = typing.TypeVar("_T") - - -def _timedelta_as_isostr(td: timedelta) -> str: - """Converts a datetime.timedelta object into an ISO 8601 formatted string, e.g. 'P4DT12H30M05S' - - Function adapted from the Tin Can Python project: https://github.com/RusticiSoftware/TinCanPython - - :param timedelta td: The timedelta to convert - :rtype: str - :return: ISO8601 version of this timedelta - """ - - # Split seconds to larger units - seconds = td.total_seconds() - minutes, seconds = divmod(seconds, 60) - hours, minutes = divmod(minutes, 60) - days, hours = divmod(hours, 24) - - days, hours, minutes = list(map(int, (days, hours, minutes))) - seconds = round(seconds, 6) - - # Build date - date_str = "" - if days: - date_str = "%sD" % days - - if hours or minutes or seconds: - # Build time - time_str = "T" - - # Hours - bigger_exists = date_str or hours - if bigger_exists: - time_str += "{:02}H".format(hours) - - # Minutes - bigger_exists = bigger_exists or minutes - if bigger_exists: - time_str += "{:02}M".format(minutes) - - # Seconds - try: - if seconds.is_integer(): - seconds_string = "{:02}".format(int(seconds)) - else: - # 9 chars long w/ leading 0, 6 digits after decimal - seconds_string = "%09.6f" % seconds - # Remove trailing zeros - seconds_string = seconds_string.rstrip("0") - except AttributeError: # int.is_integer() raises - seconds_string = "{:02}".format(seconds) - - time_str += "{}S".format(seconds_string) - else: - time_str = "" - - return "P" + date_str + time_str - - -def _serialize_bytes(o, format: typing.Optional[str] = None) -> str: - encoded = base64.b64encode(o).decode() - if format == "base64url": - return encoded.strip("=").replace("+", "-").replace("/", "_") - return encoded - - -def _serialize_datetime(o, format: typing.Optional[str] = None): - if hasattr(o, "year") and hasattr(o, "hour"): - if format == "rfc7231": - return email.utils.format_datetime(o, usegmt=True) - if format == "unix-timestamp": - return int(calendar.timegm(o.utctimetuple())) - - # astimezone() fails for naive times in Python 2.7, so make make sure o is aware (tzinfo is set) - if not o.tzinfo: - iso_formatted = o.replace(tzinfo=TZ_UTC).isoformat() - else: - iso_formatted = o.astimezone(TZ_UTC).isoformat() - # Replace the trailing "+00:00" UTC offset with "Z" (RFC 3339: https://www.ietf.org/rfc/rfc3339.txt) - return iso_formatted.replace("+00:00", "Z") - # Next try datetime.date or datetime.time - return o.isoformat() - - -def _is_readonly(p): - try: - return p._visibility == ["read"] - except AttributeError: - return False - - -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): - super().__init__(*args, **kwargs) - self.exclude_readonly = exclude_readonly - self.format = format - - 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)] - return {k: v for k, v in o.items() if k not in readonly_props} - return dict(o.items()) - try: - return super(SdkJSONEncoder, self).default(o) - except TypeError: - if isinstance(o, _Null): - return None - if isinstance(o, decimal.Decimal): - return float(o) - if isinstance(o, (bytes, bytearray)): - return _serialize_bytes(o, self.format) - try: - # First try datetime.datetime - return _serialize_datetime(o, self.format) - except AttributeError: - pass - # Last, try datetime.timedelta - try: - return _timedelta_as_isostr(o) - except AttributeError: - # This will be raised when it hits value.total_seconds in the method above - pass - 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_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" -) - - -def _deserialize_datetime(attr: typing.Union[str, datetime]) -> datetime: - """Deserialize ISO-8601 formatted string into Datetime object. - - :param str attr: response string to be deserialized. - :rtype: ~datetime.datetime - :returns: The datetime object from that input - """ - if isinstance(attr, datetime): - # i'm already deserialized - return attr - attr = attr.upper() - match = _VALID_DATE.match(attr) - if not match: - raise ValueError("Invalid datetime string: " + attr) - - check_decimal = attr.split(".") - if len(check_decimal) > 1: - decimal_str = "" - for digit in check_decimal[1]: - if digit.isdigit(): - decimal_str += digit - else: - break - if len(decimal_str) > 6: - attr = attr.replace(decimal_str, decimal_str[0:6]) - - date_obj = isodate.parse_datetime(attr) - test_utc = date_obj.utctimetuple() - if test_utc.tm_year > 9999 or test_utc.tm_year < 1: - raise OverflowError("Hit max or min date") - return date_obj - - -def _deserialize_datetime_rfc7231(attr: typing.Union[str, datetime]) -> datetime: - """Deserialize RFC7231 formatted string into Datetime object. - - :param str attr: response string to be deserialized. - :rtype: ~datetime.datetime - :returns: The datetime object from that input - """ - if isinstance(attr, datetime): - # i'm already deserialized - return attr - match = _VALID_RFC7231.match(attr) - if not match: - raise ValueError("Invalid datetime string: " + attr) - - return email.utils.parsedate_to_datetime(attr) - - -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. - :rtype: ~datetime.datetime - :returns: The datetime object from that input - """ - if isinstance(attr, datetime): - # i'm already deserialized - return attr - return datetime.fromtimestamp(attr, TZ_UTC) - - -def _deserialize_date(attr: typing.Union[str, date]) -> date: - """Deserialize ISO-8601 formatted string into Date object. - :param str attr: response string to be deserialized. - :rtype: date - :returns: The date object from that input - """ - # This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception. - if isinstance(attr, date): - return attr - return isodate.parse_date(attr, defaultmonth=None, defaultday=None) # type: ignore - - -def _deserialize_time(attr: typing.Union[str, time]) -> time: - """Deserialize ISO-8601 formatted string into time object. - - :param str attr: response string to be deserialized. - :rtype: datetime.time - :returns: The time object from that input - """ - if isinstance(attr, time): - return attr - return isodate.parse_time(attr) - - -def _deserialize_bytes(attr): - if isinstance(attr, (bytes, bytearray)): - return attr - return bytes(base64.b64decode(attr)) - - -def _deserialize_bytes_base64(attr): - if isinstance(attr, (bytes, bytearray)): - return attr - padding = "=" * (3 - (len(attr) + 3) % 4) # type: ignore - attr = attr + padding # type: ignore - encoded = attr.replace("-", "+").replace("_", "/") - return bytes(base64.b64decode(encoded)) - - -def _deserialize_duration(attr): - if isinstance(attr, timedelta): - return attr - return isodate.parse_duration(attr) - - -def _deserialize_decimal(attr): - if isinstance(attr, decimal.Decimal): - return attr - return decimal.Decimal(str(attr)) - - -def _deserialize_int_as_str(attr): - if isinstance(attr, int): - return attr - return int(attr) - - -_DESERIALIZE_MAPPING = { - datetime: _deserialize_datetime, - date: _deserialize_date, - time: _deserialize_time, - bytes: _deserialize_bytes, - bytearray: _deserialize_bytes, - timedelta: _deserialize_duration, - typing.Any: lambda x: x, - decimal.Decimal: _deserialize_decimal, -} - -_DESERIALIZE_MAPPING_WITHFORMAT = { - "rfc3339": _deserialize_datetime, - "rfc7231": _deserialize_datetime_rfc7231, - "unix-timestamp": _deserialize_datetime_unix_timestamp, - "base64": _deserialize_bytes, - "base64url": _deserialize_bytes_base64, -} - - -def get_deserializer(annotation: typing.Any, rf: typing.Optional["_RestField"] = None): - if annotation is int and rf and rf._format == "str": - return _deserialize_int_as_str - if rf and rf._format: - return _DESERIALIZE_MAPPING_WITHFORMAT.get(rf._format) - return _DESERIALIZE_MAPPING.get(annotation) # pyright: ignore - - -def _get_type_alias_type(module_name: str, alias_name: str): - types = { - k: v - for k, v in sys.modules[module_name].__dict__.items() - if isinstance(v, typing._GenericAlias) # type: ignore - } - if alias_name not in types: - return alias_name - return types[alias_name] - - -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)} - 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)}) - if isinstance(model_name, str): - model_name = model_name.split(".")[-1] - if model_name not in models: - return model_name - return models[model_name] - - -_UNSET = object() - - -class _MyMutableMapping(MutableMapping[str, typing.Any]): # pylint: disable=unsubscriptable-object - def __init__(self, data: typing.Dict[str, typing.Any]) -> None: - self._data = data - - def __contains__(self, key: typing.Any) -> bool: - return key in self._data - - def __getitem__(self, key: str) -> typing.Any: - return self._data.__getitem__(key) - - def __setitem__(self, key: str, value: typing.Any) -> None: - self._data.__setitem__(key, value) - - def __delitem__(self, key: str) -> None: - self._data.__delitem__(key) - - def __iter__(self) -> typing.Iterator[typing.Any]: - return self._data.__iter__() - - def __len__(self) -> int: - return self._data.__len__() - - def __ne__(self, other: typing.Any) -> bool: - return not self.__eq__(other) - - def keys(self) -> typing.KeysView[str]: - """ - :returns: a set-like object providing a view on D's keys - :rtype: ~typing.KeysView - """ - return self._data.keys() - - def values(self) -> typing.ValuesView[typing.Any]: - """ - :returns: an object providing a view on D's values - :rtype: ~typing.ValuesView - """ - return self._data.values() - - def items(self) -> typing.ItemsView[str, typing.Any]: - """ - :returns: set-like object providing a view on D's items - :rtype: ~typing.ItemsView - """ - return self._data.items() - - def get(self, key: str, default: typing.Any = None) -> typing.Any: - """ - Get the value for key if key is in the dictionary, else default. - :param str key: The key to look up. - :param any default: The value to return if key is not in the dictionary. Defaults to None - :returns: D[k] if k in D, else d. - :rtype: any - """ - try: - return self[key] - except KeyError: - return default - - @typing.overload - def pop(self, key: str) -> typing.Any: ... - - @typing.overload - def pop(self, key: str, default: _T) -> _T: ... - - @typing.overload - def pop(self, key: str, default: typing.Any) -> typing.Any: ... - - def pop(self, key: str, default: typing.Any = _UNSET) -> typing.Any: - """ - Removes specified key and return the corresponding value. - :param str key: The key to pop. - :param any default: The value to return if key is not in the dictionary - :returns: The value corresponding to the key. - :rtype: any - :raises KeyError: If key is not found and default is not given. - """ - if default is _UNSET: - return self._data.pop(key) - return self._data.pop(key, default) - - def popitem(self) -> typing.Tuple[str, typing.Any]: - """ - Removes and returns some (key, value) pair - :returns: The (key, value) pair. - :rtype: tuple - :raises KeyError: if D is empty. - """ - return self._data.popitem() - - def clear(self) -> None: - """ - Remove all items from D. - """ - self._data.clear() - - def update(self, *args: typing.Any, **kwargs: typing.Any) -> None: - """ - Updates D from mapping/iterable E and F. - :param any args: Either a mapping object or an iterable of key-value pairs. - """ - self._data.update(*args, **kwargs) - - @typing.overload - def setdefault(self, key: str, default: None = None) -> None: ... - - @typing.overload - def setdefault(self, key: str, default: typing.Any) -> typing.Any: ... - - def setdefault(self, key: str, default: typing.Any = _UNSET) -> typing.Any: - """ - Same as calling D.get(k, d), and setting D[k]=d if k not found - :param str key: The key to look up. - :param any default: The value to set if key is not in the dictionary - :returns: D[k] if k in D, else d. - :rtype: any - """ - if default is _UNSET: - return self._data.setdefault(key) - return self._data.setdefault(key, default) - - def __eq__(self, other: typing.Any) -> bool: - try: - other_model = self.__class__(other) - except Exception: - return False - return self._data == other_model._data - - def __repr__(self) -> str: - return str(self._data) - - -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 - if isinstance(o, list): - return [_serialize(x, format) for x in o] - if isinstance(o, dict): - return {k: _serialize(v, format) for k, v in o.items()} - if isinstance(o, set): - return {_serialize(x, format) for x in o} - if isinstance(o, tuple): - return tuple(_serialize(x, format) for x in o) - if isinstance(o, (bytes, bytearray)): - return _serialize_bytes(o, format) - if isinstance(o, decimal.Decimal): - return float(o) - if isinstance(o, enum.Enum): - return o.value - if isinstance(o, int): - if format == "str": - return str(o) - return o - try: - # First try datetime.datetime - return _serialize_datetime(o, format) - except AttributeError: - pass - # Last, try datetime.timedelta - try: - return _timedelta_as_isostr(o) - except AttributeError: - # This will be raised when it hits value.total_seconds in the method above - pass - return o - - -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) - except StopIteration: - return None - - -def _create_value(rf: typing.Optional["_RestField"], value: typing.Any) -> typing.Any: - if not rf: - return _serialize(value, None) - if rf._is_multipart_file_input: - return value - if rf._is_model: - return _deserialize(rf._type, value) - if isinstance(value, ET.Element): - value = _deserialize(rf._type, value) - return _serialize(value, rf._format) - - -class Model(_MyMutableMapping): - _is_model = True - # label whether current class's _attr_to_rest_field has been calculated - # could not see _attr_to_rest_field directly because subclass inherits it from parent class - _calculated: typing.Set[str] = set() - - 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") - dict_to_pass = { - rest_field._rest_name: rest_field._default - for rest_field in self._attr_to_rest_field.values() - if rest_field._default is not _UNSET - } - if args: # pylint: disable=too-many-nested-blocks - if isinstance(args[0], ET.Element): - existed_attr_keys = [] - model_meta = getattr(self, "_xml", {}) - - for rf in self._attr_to_rest_field.values(): - prop_meta = getattr(rf, "_xml", {}) - xml_name = prop_meta.get("name", rf._rest_name) - xml_ns = prop_meta.get("ns", model_meta.get("ns", None)) - if xml_ns: - xml_name = "{" + xml_ns + "}" + xml_name - - # attribute - 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)) - continue - - # unwrapped element is array - if prop_meta.get("unwrapped", False): - # unwrapped array could either use prop items meta/prop meta - if prop_meta.get("itemsName"): - xml_name = prop_meta.get("itemsName") - xml_ns = prop_meta.get("itemNs") - if xml_ns: - xml_name = "{" + xml_ns + "}" + xml_name - items = args[0].findall(xml_name) # pyright: ignore - if len(items) > 0: - existed_attr_keys.append(xml_name) - dict_to_pass[rf._rest_name] = _deserialize(rf._type, items) - continue - - # 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) - continue - - # wrapped element could be normal property or array, it should only have one element - item = args[0].find(xml_name) - if item is not None: - existed_attr_keys.append(xml_name) - dict_to_pass[rf._rest_name] = _deserialize(rf._type, item) - - # rest thing is additional properties - for e in args[0]: - if e.tag not in existed_attr_keys: - 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()} - ) - 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]}'") - dict_to_pass.update( - { - 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 - } - ) - super().__init__(dict_to_pass) - - def copy(self) -> "Model": - return Model(self.__dict__) - - def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> Self: - if f"{cls.__module__}.{cls.__qualname__}" not in cls._calculated: - # 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") - } - annotations = { - k: v - for mro_class in mros - if hasattr(mro_class, "__annotations__") - for k, v in mro_class.__annotations__.items() - } - 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)) - 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._calculated.add(f"{cls.__module__}.{cls.__qualname__}") - - return super().__new__(cls) # pylint: disable=no-value-for-parameter - - def __init_subclass__(cls, discriminator: typing.Optional[str] = None) -> None: - for base in cls.__bases__: - if hasattr(base, "__mapping__"): - base.__mapping__[discriminator or cls.__name__] = cls # type: ignore - - @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: - return v - return None - - @classmethod - def _deserialize(cls, data, exist_discriminators): - if not hasattr(cls, "__mapping__"): - return cls(data) - discriminator = cls._get_discriminator(exist_discriminators) - if discriminator is None: - return cls(data) - exist_discriminators.append(discriminator._rest_name) - if isinstance(data, ET.Element): - model_meta = getattr(cls, "_xml", {}) - prop_meta = getattr(discriminator, "_xml", {}) - xml_name = prop_meta.get("name", discriminator._rest_name) - xml_ns = prop_meta.get("ns", model_meta.get("ns", None)) - if xml_ns: - xml_name = "{" + xml_ns + "}" + xml_name - - if data.get(xml_name) is not None: - discriminator_value = data.get(xml_name) - else: - 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 - return mapped_cls._deserialize(data, exist_discriminators) - - 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. - :returns: A dict JSON compatible object - :rtype: dict - """ - - result = {} - readonly_props = [] - if exclude_readonly: - 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 - is_multipart_file_input = False - try: - is_multipart_file_input = next( - rf for rf in self._attr_to_rest_field.values() if rf._rest_name == k - )._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) - return result - - @staticmethod - 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) - 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 - - -def _deserialize_model(model_deserializer: typing.Optional[typing.Callable], obj): - if _is_model(obj): - return obj - return _deserialize(model_deserializer, 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) - - -def _deserialize_with_union(deserializers, obj): - for deserializer in deserializers: - try: - return _deserialize(deserializer, obj) - except DeserializationError: - pass - raise DeserializationError() - - -def _deserialize_dict( - value_deserializer: typing.Optional[typing.Callable], - module: typing.Optional[str], - obj: typing.Dict[typing.Any, typing.Any], -): - if obj is None: - return obj - if isinstance(obj, ET.Element): - obj = {child.tag: child for child in obj} - return {k: _deserialize(value_deserializer, v, module) for k, v in obj.items()} - - -def _deserialize_multiple_sequence( - entry_deserializers: typing.List[typing.Optional[typing.Callable]], - module: typing.Optional[str], - obj, -): - if obj is None: - return obj - return type(obj)(_deserialize(deserializer, entry, module) for entry, deserializer in zip(obj, entry_deserializers)) - - -def _deserialize_sequence( - deserializer: typing.Optional[typing.Callable], - module: typing.Optional[str], - obj, -): - if obj is None: - return obj - if isinstance(obj, ET.Element): - obj = list(obj) - return type(obj)(_deserialize(deserializer, entry, module) for entry in obj) - - -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"), - ) - - -def _get_deserialize_callable_from_annotation( # pylint: disable=too-many-return-statements, too-many-branches - annotation: typing.Any, - module: typing.Optional[str], - rf: typing.Optional["_RestField"] = None, -) -> typing.Optional[typing.Callable[[typing.Any], typing.Any]]: - if not annotation: - return None - - # is it a type alias? - if isinstance(annotation, str): - if module is not None: - annotation = _get_type_alias_type(module, annotation) - - # is it a forward ref / in quotes? - if isinstance(annotation, (str, typing.ForwardRef)): - try: - model_name = annotation.__forward_arg__ # type: ignore - except AttributeError: - model_name = annotation - if module is not None: - annotation = _get_model(module, model_name) # type: ignore - - try: - if module and _is_model(annotation): - if rf: - rf._is_model = True - - return functools.partial(_deserialize_model, annotation) # pyright: ignore - except Exception: - pass - - # is it a literal? - try: - if annotation.__origin__ is typing.Literal: # pyright: ignore - return None - except AttributeError: - pass - - # is it optional? - try: - 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 - ) - - 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) - except AttributeError: - pass - - # is it union? - if getattr(annotation, "__origin__", None) is typing.Union: - # initial ordering is we make `string` the last deserialization option, because it is often them most generic - deserializers = [ - _get_deserialize_callable_from_annotation(arg, module, rf) - for arg in _sorted_annotations(annotation.__args__) # pyright: ignore - ] - - return functools.partial(_deserialize_with_union, deserializers) - - try: - if annotation._name == "Dict": # pyright: ignore - value_deserializer = _get_deserialize_callable_from_annotation( - annotation.__args__[1], module, rf # pyright: ignore - ) - - return functools.partial( - _deserialize_dict, - value_deserializer, - module, - ) - except (AttributeError, IndexError): - pass - try: - if annotation._name in ["List", "Set", "Tuple", "Sequence"]: # pyright: ignore - 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) - deserializer = _get_deserialize_callable_from_annotation( - annotation.__args__[0], module, rf # pyright: ignore - ) - - return functools.partial(_deserialize_sequence, deserializer, module) - except (TypeError, IndexError, AttributeError, SyntaxError): - pass - - def _deserialize_default( - deserializer, - obj, - ): - if obj is None: - return obj - try: - return _deserialize_with_callable(deserializer, obj) - except Exception: - pass - return obj - - if get_deserializer(annotation, rf): - return functools.partial(_deserialize_default, get_deserializer(annotation, rf)) - - return functools.partial(_deserialize_default, annotation) - - -def _deserialize_with_callable( - deserializer: typing.Optional[typing.Callable[[typing.Any], typing.Any]], - value: typing.Any, -): # pylint: disable=too-many-return-statements - try: - if value is None or isinstance(value, _Null): - return None - if isinstance(value, ET.Element): - if deserializer is str: - return value.text or "" - if deserializer is int: - return int(value.text) if value.text else None - if deserializer is float: - return float(value.text) if value.text else None - if deserializer is bool: - return value.text == "true" if value.text else None - if deserializer is None: - return value - if deserializer in [int, float, bool]: - return deserializer(value) - if isinstance(deserializer, CaseInsensitiveEnumMeta): - try: - return deserializer(value) - except ValueError: - # for unknown value, return raw value - 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) - except Exception as e: - raise DeserializationError() from e - - -def _deserialize( - deserializer: typing.Any, - value: typing.Any, - module: typing.Optional[str] = None, - rf: typing.Optional["_RestField"] = None, - format: typing.Optional[str] = None, -) -> typing.Any: - if isinstance(value, PipelineResponse): - value = value.http_response.json() - 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) - return _deserialize_with_callable(deserializer, value) - - -def _failsafe_deserialize( - deserializer: typing.Any, - value: typing.Any, - module: typing.Optional[str] = None, - rf: typing.Optional["_RestField"] = None, - format: typing.Optional[str] = None, -) -> typing.Any: - try: - 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 - ) - return None - - -def _failsafe_deserialize_xml( - deserializer: typing.Any, - value: typing.Any, -) -> typing.Any: - try: - return _deserialize_xml(deserializer, value) - except DeserializationError: - _LOGGER.warning( - "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True - ) - return None - - -class _RestField: - def __init__( - self, - *, - name: typing.Optional[str] = None, - 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, - format: typing.Optional[str] = None, - is_multipart_file_input: bool = False, - xml: typing.Optional[typing.Dict[str, typing.Any]] = None, - ): - self._type = type - self._rest_name_input = name - self._module: typing.Optional[str] = None - self._is_discriminator = is_discriminator - self._visibility = visibility - self._is_model = False - self._default = default - self._format = format - self._is_multipart_file_input = is_multipart_file_input - self._xml = xml if xml is not None else {} - - @property - def _class_type(self) -> typing.Any: - return getattr(self._type, "args", [None])[0] - - @property - def _rest_name(self) -> str: - if self._rest_name_input is None: - raise ValueError("Rest name was never set") - return self._rest_name_input - - def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin - # by this point, type and rest_name will have a value bc we default - # them in __new__ of the Model class - item = obj.get(self._rest_name) - if item is None: - return item - if self._is_model: - return item - return _deserialize(self._type, _serialize(item, self._format), rf=self) - - def __set__(self, obj: Model, value) -> None: - if value is None: - # we want to wipe out entries if users set attr to None - try: - obj.__delitem__(self._rest_name) - except KeyError: - pass - return - if self._is_model: - if not _is_model(value): - value = _deserialize(self._type, value) - obj.__setitem__(self._rest_name, value) - return - obj.__setitem__(self._rest_name, _serialize(value, self._format)) - - def _get_deserialize_callable_from_annotation( - self, annotation: typing.Any - ) -> typing.Optional[typing.Callable[[typing.Any], typing.Any]]: - return _get_deserialize_callable_from_annotation(annotation, self._module, self) - - -def rest_field( - *, - name: typing.Optional[str] = None, - type: typing.Optional[typing.Callable] = None, # pylint: disable=redefined-builtin - visibility: typing.Optional[typing.List[str]] = None, - default: typing.Any = _UNSET, - format: typing.Optional[str] = None, - is_multipart_file_input: bool = False, - xml: typing.Optional[typing.Dict[str, typing.Any]] = None, -) -> typing.Any: - return _RestField( - name=name, - type=type, - visibility=visibility, - default=default, - format=format, - is_multipart_file_input=is_multipart_file_input, - xml=xml, - ) - - -def rest_discriminator( - *, - name: typing.Optional[str] = None, - type: typing.Optional[typing.Callable] = None, # pylint: disable=redefined-builtin - 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) - - -def serialize_xml(model: Model, exclude_readonly: bool = False) -> str: - """Serialize a model to XML. - - :param Model model: The model to serialize. - :param bool exclude_readonly: Whether to exclude readonly properties. - :returns: The XML representation of the model. - :rtype: str - """ - return ET.tostring(_get_element(model, exclude_readonly), encoding="unicode") # type: ignore - - -def _get_element( - o: typing.Any, - exclude_readonly: bool = False, - parent_meta: typing.Optional[typing.Dict[str, typing.Any]] = None, - wrapped_element: typing.Optional[ET.Element] = None, -) -> typing.Union[ET.Element, typing.List[ET.Element]]: - if _is_model(o): - model_meta = getattr(o, "_xml", {}) - - # if prop is a model, then use the prop element directly, else generate a wrapper of model - if wrapped_element is None: - wrapped_element = _create_xml_element( - model_meta.get("name", o.__class__.__name__), - model_meta.get("prefix"), - model_meta.get("ns"), - ) - - readonly_props = [] - if exclude_readonly: - 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 - if exclude_readonly and k in readonly_props: - continue - - prop_rest_field = _get_rest_field(o._attr_to_rest_field, k) - if prop_rest_field: - prop_meta = getattr(prop_rest_field, "_xml").copy() - # use the wire name as xml name if no specific name is set - if prop_meta.get("name") is None: - prop_meta["name"] = k - else: - # additional properties will not have rest field, use the wire name as xml name - prop_meta = {"name": k} - - # if no ns for prop, use model's - if prop_meta.get("ns") is None and model_meta.get("ns"): - prop_meta["ns"] = model_meta.get("ns") - prop_meta["prefix"] = model_meta.get("prefix") - - if prop_meta.get("unwrapped", False): - # unwrapped could only set on array - wrapped_element.extend(_get_element(v, exclude_readonly, prop_meta)) - elif prop_meta.get("text", False): - # text could only set on primitive type - wrapped_element.text = _get_primitive_type_value(v) - 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 - # 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)) - return wrapped_element - if isinstance(o, list): - return [_get_element(x, exclude_readonly, parent_meta) for x in o] # type: ignore - if isinstance(o, dict): - result = [] - for k, v in o.items(): - result.append( - _get_wrapped_element( - v, - exclude_readonly, - { - "name": k, - "ns": parent_meta.get("ns") if parent_meta else None, - "prefix": parent_meta.get("prefix") if parent_meta else None, - }, - ) - ) - return result - - # primitive case need to create element based on parent_meta - if parent_meta: - return _get_wrapped_element( - o, - exclude_readonly, - { - "name": parent_meta.get("itemsName", parent_meta.get("name")), - "prefix": parent_meta.get("itemsPrefix", parent_meta.get("prefix")), - "ns": parent_meta.get("itemsNs", parent_meta.get("ns")), - }, - ) - - raise ValueError("Could not serialize value into xml: " + o) - - -def _get_wrapped_element( - v: typing.Any, - exclude_readonly: bool, - 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 - ) - if isinstance(v, (dict, list)): - wrapped_element.extend(_get_element(v, exclude_readonly, meta)) - elif _is_model(v): - _get_element(v, exclude_readonly, meta, wrapped_element) - else: - wrapped_element.text = _get_primitive_type_value(v) - return wrapped_element - - -def _get_primitive_type_value(v) -> str: - if v is True: - return "true" - if v is False: - return "false" - if isinstance(v, _Null): - return "" - return str(v) - - -def _create_xml_element(tag, prefix=None, ns=None): - if prefix and ns: - ET.register_namespace(prefix, ns) - if ns: - return ET.Element("{" + ns + "}" + tag) - return ET.Element(tag) - - -def _deserialize_xml( - deserializer: typing.Any, - value: str, -) -> typing.Any: - element = ET.fromstring(value) # nosec - return _deserialize(deserializer, element) - - -def _convert_element(e: ET.Element): - # dict case - if len(e.attrib) > 0 or len({child.tag for child in e}) > 1: - dict_result: typing.Dict[str, typing.Any] = {} - for child in e: - if dict_result.get(child.tag) is not None: - 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)] - else: - dict_result[child.tag] = _convert_element(child) - dict_result.update(e.attrib) - return dict_result - # array case - if len(e) > 0: - array_result: typing.List[typing.Any] = [] - for child in e: - array_result.append(_convert_element(child)) - return array_result - # primitive case - return e.text diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_utils/__init__.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_utils/__init__.py new file mode 100644 index 000000000000..0af9b28f6607 --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_utils/__init__.py @@ -0,0 +1,6 @@ +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_serialization.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_utils/serialization.py similarity index 98% rename from sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_serialization.py rename to sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_utils/serialization.py index a066e16a64dd..f5187701d7be 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_serialization.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_utils/serialization.py @@ -1,28 +1,10 @@ -# pylint: disable=too-many-lines +# pylint: disable=line-too-long,useless-suppression,too-many-lines +# coding=utf-8 # -------------------------------------------------------------------------- -# # Copyright (c) Microsoft Corporation. All rights reserved. -# -# The MIT License (MIT) -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the ""Software""), to -# deal in the Software without restriction, including without limitation the -# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -# sell copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -# IN THE SOFTWARE. -# +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- # pyright: reportUnnecessaryTypeIgnoreComment=false @@ -411,7 +393,7 @@ def from_dict( :param function key_extractors: A key extractor function. :param str content_type: JSON by default, set application/xml if XML. :returns: An instance of this model - :raises: DeserializationError if something went wrong + :raises DeserializationError: if something went wrong :rtype: Self """ deserializer = Deserializer(cls._infer_class_models()) @@ -1361,7 +1343,7 @@ def xml_key_extractor(attr, attr_desc, data): # pylint: disable=unused-argument # Iter and wrapped, should have found one node only (the wrap one) if len(children) != 1: raise DeserializationError( - "Tried to deserialize an array not wrapped, and found several nodes '{}'. Maybe you should declare this array as wrapped?".format( # pylint: disable=line-too-long + "Tried to deserialize an array not wrapped, and found several nodes '{}'. Maybe you should declare this array as wrapped?".format( xml_name ) ) diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_validation.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_validation.py deleted file mode 100644 index 752b2822f9d3..000000000000 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_validation.py +++ /dev/null @@ -1,50 +0,0 @@ -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import functools - - -def api_version_validation(**kwargs): - params_added_on = kwargs.pop("params_added_on", {}) - method_added_on = kwargs.pop("method_added_on", "") - - def decorator(func): - @functools.wraps(func) - def wrapper(*args, **kwargs): - try: - # this assumes the client has an _api_version attribute - client = args[0] - client_api_version = client._config.api_version # pylint: disable=protected-access - except AttributeError: - return func(*args, **kwargs) - - if method_added_on > client_api_version: - raise ValueError( - f"'{func.__name__}' is not available in API version " - f"{client_api_version}. Pass service API version {method_added_on} or newer to your client." - ) - - unsupported = { - parameter: api_version - for api_version, parameters in params_added_on.items() - for parameter in parameters - if parameter in kwargs and api_version > client_api_version - } - if unsupported: - raise ValueError( - "".join( - [ - f"'{param}' is not available in API version {client_api_version}. " - f"Use service API version {version} or newer.\n" - for param, version in unsupported.items() - ] - ) - ) - return func(*args, **kwargs) - - return wrapper - - return decorator diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_version.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_version.py index be71c81bd282..c47f66669f1b 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_version.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/_version.py @@ -2,8 +2,8 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "1.0.0b1" +VERSION = "1.0.0" diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/__init__.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/__init__.py index fe4dfe48765a..01aa7e8dd18c 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/__init__.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/__init__.py @@ -2,7 +2,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- # pylint: disable=wrong-import-position @@ -12,7 +12,7 @@ if TYPE_CHECKING: from ._patch import * # pylint: disable=unused-wildcard-import -from ._client import DatabaseWatcherMgmtClient # type: ignore +from ._microsoft_database_watcher import MicrosoftDatabaseWatcher # type: ignore try: from ._patch import __all__ as _patch_all @@ -22,7 +22,7 @@ from ._patch import patch_sdk as _patch_sdk __all__ = [ - "DatabaseWatcherMgmtClient", + "MicrosoftDatabaseWatcher", ] __all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/_configuration.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/_configuration.py index 25ac4c853e95..812609f97559 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/_configuration.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/_configuration.py @@ -2,7 +2,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- @@ -17,30 +17,22 @@ from azure.core.credentials_async import AsyncTokenCredential -class DatabaseWatcherMgmtClientConfiguration: # pylint: disable=too-many-instance-attributes - """Configuration for DatabaseWatcherMgmtClient. +class MicrosoftDatabaseWatcherConfiguration: # pylint: disable=too-many-instance-attributes + """Configuration for MicrosoftDatabaseWatcher. Note that all parameters used to create this instance are saved as instance attributes. - :param credential: Credential used to authenticate requests to the service. Required. + :param credential: Credential needed for the client to connect to Azure. Required. :type credential: ~azure.core.credentials_async.AsyncTokenCredential :param subscription_id: The ID of the target subscription. The value must be an UUID. Required. :type subscription_id: str - :param base_url: Service host. Default value is "https://management.azure.com". - :type base_url: str - :keyword api_version: The API version to use for this operation. Default value is "2025-01-02". - Note that overriding this default value may result in unsupported behavior. + :keyword api_version: Api Version. Default value is "2025-01-02". Note that overriding this + default value may result in unsupported behavior. :paramtype api_version: str """ - def __init__( - self, - credential: "AsyncTokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any - ) -> None: + def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: api_version: str = kwargs.pop("api_version", "2025-01-02") if credential is None: @@ -50,7 +42,6 @@ def __init__( self.credential = credential self.subscription_id = subscription_id - self.base_url = base_url self.api_version = api_version self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) kwargs.setdefault("sdk_moniker", "mgmt-databasewatcher/{}".format(VERSION)) diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/_client.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/_microsoft_database_watcher.py similarity index 77% rename from sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/_client.py rename to sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/_microsoft_database_watcher.py index 1eb6cf0c2e43..3f5f04555c01 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/_client.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/_microsoft_database_watcher.py @@ -2,21 +2,24 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from copy import deepcopy -from typing import Any, Awaitable, TYPE_CHECKING +from typing import Any, Awaitable, Optional, TYPE_CHECKING, cast from typing_extensions import Self from azure.core.pipeline import policies from azure.core.rest import AsyncHttpResponse, HttpRequest +from azure.core.settings import settings from azure.mgmt.core import AsyncARMPipelineClient from azure.mgmt.core.policies import AsyncARMAutoResourceProviderRegistrationPolicy +from azure.mgmt.core.tools import get_arm_endpoints -from .._serialization import Deserializer, Serializer -from ._configuration import DatabaseWatcherMgmtClientConfiguration +from .. import models as _models +from .._utils.serialization import Deserializer, Serializer +from ._configuration import MicrosoftDatabaseWatcherConfiguration from .operations import ( AlertRuleResourcesOperations, HealthValidationsOperations, @@ -30,8 +33,8 @@ from azure.core.credentials_async import AsyncTokenCredential -class DatabaseWatcherMgmtClient: - """DatabaseWatcherMgmtClient. +class MicrosoftDatabaseWatcher: + """MicrosoftDatabaseWatcher. :ivar operations: Operations operations :vartype operations: azure.mgmt.databasewatcher.aio.operations.Operations @@ -43,35 +46,36 @@ class DatabaseWatcherMgmtClient: :ivar health_validations: HealthValidationsOperations operations :vartype health_validations: azure.mgmt.databasewatcher.aio.operations.HealthValidationsOperations - :ivar targets: TargetsOperations operations - :vartype targets: azure.mgmt.databasewatcher.aio.operations.TargetsOperations :ivar shared_private_link_resources: SharedPrivateLinkResourcesOperations operations :vartype shared_private_link_resources: azure.mgmt.databasewatcher.aio.operations.SharedPrivateLinkResourcesOperations - :param credential: Credential used to authenticate requests to the service. Required. + :ivar targets: TargetsOperations operations + :vartype targets: azure.mgmt.databasewatcher.aio.operations.TargetsOperations + :param credential: Credential needed for the client to connect to Azure. Required. :type credential: ~azure.core.credentials_async.AsyncTokenCredential :param subscription_id: The ID of the target subscription. The value must be an UUID. Required. :type subscription_id: str - :param base_url: Service host. Default value is "https://management.azure.com". + :param base_url: Service URL. Default value is None. :type base_url: str - :keyword api_version: The API version to use for this operation. Default value is "2025-01-02". - Note that overriding this default value may result in unsupported behavior. + :keyword api_version: Api Version. Default value is "2025-01-02". Note that overriding this + default value may result in unsupported behavior. :paramtype api_version: str :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. """ def __init__( - self, - credential: "AsyncTokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any + self, credential: "AsyncTokenCredential", subscription_id: str, base_url: Optional[str] = None, **kwargs: Any ) -> None: - _endpoint = "{endpoint}" - self._config = DatabaseWatcherMgmtClientConfiguration( - credential=credential, subscription_id=subscription_id, base_url=base_url, **kwargs + _cloud = kwargs.pop("cloud_setting", None) or settings.current.azure_cloud # type: ignore + _endpoints = get_arm_endpoints(_cloud) + if not base_url: + base_url = _endpoints["resource_manager"] + credential_scopes = kwargs.pop("credential_scopes", _endpoints["credential_scopes"]) + self._config = MicrosoftDatabaseWatcherConfiguration( + credential=credential, subscription_id=subscription_id, credential_scopes=credential_scopes, **kwargs ) + _policies = kwargs.pop("policies", None) if _policies is None: _policies = [ @@ -90,10 +94,13 @@ def __init__( policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, self._config.http_logging_policy, ] - self._client: AsyncARMPipelineClient = AsyncARMPipelineClient(base_url=_endpoint, policies=_policies, **kwargs) + self._client: AsyncARMPipelineClient = AsyncARMPipelineClient( + base_url=cast(str, base_url), policies=_policies, **kwargs + ) - self._serialize = Serializer() - self._deserialize = Deserializer() + client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} + self._serialize = Serializer(client_models) + self._deserialize = Deserializer(client_models) self._serialize.client_side_validation = False self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) self.watchers = WatchersOperations(self._client, self._config, self._serialize, self._deserialize) @@ -103,12 +110,12 @@ def __init__( self.health_validations = HealthValidationsOperations( self._client, self._config, self._serialize, self._deserialize ) - self.targets = TargetsOperations(self._client, self._config, self._serialize, self._deserialize) self.shared_private_link_resources = SharedPrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) + self.targets = TargetsOperations(self._client, self._config, self._serialize, self._deserialize) - def send_request( + def _send_request( self, request: HttpRequest, *, stream: bool = False, **kwargs: Any ) -> Awaitable[AsyncHttpResponse]: """Runs the network request through the client's chained policies. @@ -116,7 +123,7 @@ def send_request( >>> from azure.core.rest import HttpRequest >>> request = HttpRequest("GET", "https://www.example.org/") - >>> response = await client.send_request(request) + >>> response = await client._send_request(request) For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request @@ -129,11 +136,7 @@ def send_request( """ request_copy = deepcopy(request) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments) + request_copy.url = self._client.format_url(request_copy.url) return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore async def close(self) -> None: diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/__init__.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/__init__.py index c6940b5bbb72..bd3753b59109 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/__init__.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/__init__.py @@ -2,7 +2,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- # pylint: disable=wrong-import-position @@ -13,11 +13,11 @@ from ._patch import * # pylint: disable=unused-wildcard-import from ._operations import Operations # type: ignore -from ._operations import WatchersOperations # type: ignore -from ._operations import AlertRuleResourcesOperations # type: ignore -from ._operations import HealthValidationsOperations # type: ignore -from ._operations import TargetsOperations # type: ignore -from ._operations import SharedPrivateLinkResourcesOperations # type: ignore +from ._watchers_operations import WatchersOperations # type: ignore +from ._alert_rule_resources_operations import AlertRuleResourcesOperations # type: ignore +from ._health_validations_operations import HealthValidationsOperations # type: ignore +from ._shared_private_link_resources_operations import SharedPrivateLinkResourcesOperations # type: ignore +from ._targets_operations import TargetsOperations # type: ignore from ._patch import __all__ as _patch_all from ._patch import * @@ -28,8 +28,8 @@ "WatchersOperations", "AlertRuleResourcesOperations", "HealthValidationsOperations", - "TargetsOperations", "SharedPrivateLinkResourcesOperations", + "TargetsOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_alert_rule_resources_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_alert_rule_resources_operations.py new file mode 100644 index 000000000000..6989046ad246 --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_alert_rule_resources_operations.py @@ -0,0 +1,405 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from collections.abc import MutableMapping +from io import IOBase +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +import urllib.parse + +from azure.core import AsyncPipelineClient +from azure.core.async_paging import AsyncItemPaged, AsyncList +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) +from azure.core.pipeline import PipelineResponse +from azure.core.rest import AsyncHttpResponse, HttpRequest +from azure.core.tracing.decorator import distributed_trace +from azure.core.tracing.decorator_async import distributed_trace_async +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat + +from ... import models as _models +from ..._utils.serialization import Deserializer, Serializer +from ...operations._alert_rule_resources_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_parent_request, +) +from .._configuration import MicrosoftDatabaseWatcherConfiguration + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + + +class AlertRuleResourcesOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.databasewatcher.aio.MicrosoftDatabaseWatcher`'s + :attr:`alert_rule_resources` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: MicrosoftDatabaseWatcherConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def list_by_parent( + self, resource_group_name: str, watcher_name: str, **kwargs: Any + ) -> AsyncIterable["_models.AlertRuleResource"]: + """List AlertRuleResource resources by Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: An iterator like instance of either AlertRuleResource or the result of cls(response) + :rtype: + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.databasewatcher.models.AlertRuleResource] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.AlertRuleResourceListResult] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_list_by_parent_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request + + async def extract_data(pipeline_response): + deserialized = self._deserialize("AlertRuleResourceListResult", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.next_link or None, AsyncList(list_of_elem) + + async def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return AsyncItemPaged(get_next, extract_data) + + @distributed_trace_async + async def get( + self, resource_group_name: str, watcher_name: str, alert_rule_resource_name: str, **kwargs: Any + ) -> _models.AlertRuleResource: + """Get a AlertRuleResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param alert_rule_resource_name: The alert rule proxy resource name. Required. + :type alert_rule_resource_name: str + :return: AlertRuleResource or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.AlertRuleResource] = kwargs.pop("cls", None) + + _request = build_get_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + alert_rule_resource_name=alert_rule_resource_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("AlertRuleResource", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @overload + async def create_or_update( + self, + resource_group_name: str, + watcher_name: str, + alert_rule_resource_name: str, + resource: _models.AlertRuleResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AlertRuleResource: + """Create a AlertRuleResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param alert_rule_resource_name: The alert rule proxy resource name. Required. + :type alert_rule_resource_name: str + :param resource: Resource create parameters. Required. + :type resource: ~azure.mgmt.databasewatcher.models.AlertRuleResource + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: AlertRuleResource or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + watcher_name: str, + alert_rule_resource_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AlertRuleResource: + """Create a AlertRuleResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param alert_rule_resource_name: The alert rule proxy resource name. Required. + :type alert_rule_resource_name: str + :param resource: Resource create parameters. Required. + :type resource: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: AlertRuleResource or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + watcher_name: str, + alert_rule_resource_name: str, + resource: Union[_models.AlertRuleResource, IO[bytes]], + **kwargs: Any + ) -> _models.AlertRuleResource: + """Create a AlertRuleResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param alert_rule_resource_name: The alert rule proxy resource name. Required. + :type alert_rule_resource_name: str + :param resource: Resource create parameters. Is either a AlertRuleResource type or a IO[bytes] + type. Required. + :type resource: ~azure.mgmt.databasewatcher.models.AlertRuleResource or IO[bytes] + :return: AlertRuleResource or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.AlertRuleResource] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(resource, (IOBase, bytes)): + _content = resource + else: + _json = self._serialize.body(resource, "AlertRuleResource") + + _request = build_create_or_update_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + alert_rule_resource_name=alert_rule_resource_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("AlertRuleResource", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def delete( + self, resource_group_name: str, watcher_name: str, alert_rule_resource_name: str, **kwargs: Any + ) -> None: + """Delete a AlertRuleResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param alert_rule_resource_name: The alert rule proxy resource name. Required. + :type alert_rule_resource_name: str + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_delete_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + alert_rule_resource_name=alert_rule_resource_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 204]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if cls: + return cls(pipeline_response, None, {}) # type: ignore diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_health_validations_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_health_validations_operations.py new file mode 100644 index 000000000000..11cba68c82f5 --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_health_validations_operations.py @@ -0,0 +1,331 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from collections.abc import MutableMapping +from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, Optional, TypeVar, Union, cast +import urllib.parse + +from azure.core import AsyncPipelineClient +from azure.core.async_paging import AsyncItemPaged, AsyncList +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, + map_error, +) +from azure.core.pipeline import PipelineResponse +from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod +from azure.core.rest import AsyncHttpResponse, HttpRequest +from azure.core.tracing.decorator import distributed_trace +from azure.core.tracing.decorator_async import distributed_trace_async +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat +from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling + +from ... import models as _models +from ..._utils.serialization import Deserializer, Serializer +from ...operations._health_validations_operations import ( + build_get_request, + build_list_by_parent_request, + build_start_validation_request, +) +from .._configuration import MicrosoftDatabaseWatcherConfiguration + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + + +class HealthValidationsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.databasewatcher.aio.MicrosoftDatabaseWatcher`'s + :attr:`health_validations` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: MicrosoftDatabaseWatcherConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def list_by_parent( + self, resource_group_name: str, watcher_name: str, **kwargs: Any + ) -> AsyncIterable["_models.HealthValidation"]: + """List HealthValidation resources by Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: An iterator like instance of either HealthValidation or the result of cls(response) + :rtype: + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.databasewatcher.models.HealthValidation] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.HealthValidationListResult] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_list_by_parent_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request + + async def extract_data(pipeline_response): + deserialized = self._deserialize("HealthValidationListResult", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.next_link or None, AsyncList(list_of_elem) + + async def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return AsyncItemPaged(get_next, extract_data) + + @distributed_trace_async + async def get( + self, resource_group_name: str, watcher_name: str, health_validation_name: str, **kwargs: Any + ) -> _models.HealthValidation: + """Get a HealthValidation. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param health_validation_name: The health validation resource name. Required. + :type health_validation_name: str + :return: HealthValidation or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.HealthValidation + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.HealthValidation] = kwargs.pop("cls", None) + + _request = build_get_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + health_validation_name=health_validation_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("HealthValidation", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + async def _start_validation_initial( + self, resource_group_name: str, watcher_name: str, health_validation_name: str, **kwargs: Any + ) -> AsyncIterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) + + _request = build_start_validation_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + health_validation_name=health_validation_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 202]: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 202: + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def begin_start_validation( + self, resource_group_name: str, watcher_name: str, health_validation_name: str, **kwargs: Any + ) -> AsyncLROPoller[_models.HealthValidation]: + """Starts health validation for a watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param health_validation_name: The health validation resource name. Required. + :type health_validation_name: str + :return: An instance of AsyncLROPoller that returns either HealthValidation or the result of + cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.HealthValidation] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.HealthValidation] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = await self._start_validation_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + health_validation_name=health_validation_name, + api_version=api_version, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + await raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): + deserialized = self._deserialize("HealthValidation", pipeline_response.http_response) + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + return deserialized + + if polling is True: + polling_method: AsyncPollingMethod = cast( + AsyncPollingMethod, AsyncARMPolling(lro_delay, lro_options={"final-state-via": "location"}, **kwargs) + ) + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling + if cont_token: + return AsyncLROPoller[_models.HealthValidation].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return AsyncLROPoller[_models.HealthValidation]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_operations.py index 2301a7213687..6220bedf0abf 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_operations.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_operations.py @@ -1,15 +1,12 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from io import IOBase -import json -import sys -from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, List, Optional, TypeVar, Union, cast, overload +from collections.abc import MutableMapping +from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar import urllib.parse from azure.core import AsyncPipelineClient @@ -20,58 +17,21 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, - StreamClosedError, - StreamConsumedError, map_error, ) from azure.core.pipeline import PipelineResponse -from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling from ... import models as _models -from ..._model_base import SdkJSONEncoder, _deserialize, _failsafe_deserialize -from ..._serialization import Deserializer, Serializer -from ..._validation import api_version_validation -from ...operations._operations import ( - build_alert_rule_resources_create_or_update_request, - build_alert_rule_resources_delete_request, - build_alert_rule_resources_get_request, - build_alert_rule_resources_list_by_parent_request, - build_health_validations_get_request, - build_health_validations_list_by_parent_request, - build_health_validations_start_validation_request, - build_operations_list_request, - build_shared_private_link_resources_create_request, - build_shared_private_link_resources_delete_request, - build_shared_private_link_resources_get_request, - build_shared_private_link_resources_list_by_watcher_request, - build_targets_create_or_update_request, - build_targets_delete_request, - build_targets_get_request, - build_targets_list_by_watcher_request, - build_watchers_create_or_update_request, - build_watchers_delete_request, - build_watchers_get_request, - build_watchers_list_by_resource_group_request, - build_watchers_list_by_subscription_request, - build_watchers_start_request, - build_watchers_stop_request, - build_watchers_update_request, -) -from .._configuration import DatabaseWatcherMgmtClientConfiguration +from ..._utils.serialization import Deserializer, Serializer +from ...operations._operations import build_list_request +from .._configuration import MicrosoftDatabaseWatcherConfiguration -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] -JSON = MutableMapping[str, Any] # pylint: disable=unsubscriptable-object class Operations: @@ -80,14 +40,16 @@ class Operations: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.databasewatcher.aio.DatabaseWatcherMgmtClient`'s + :class:`~azure.mgmt.databasewatcher.aio.MicrosoftDatabaseWatcher`'s :attr:`operations` attribute. """ + models = _models + def __init__(self, *args, **kwargs) -> None: input_args = list(args) self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: DatabaseWatcherMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._config: MicrosoftDatabaseWatcherConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @@ -95,755 +57,15 @@ def __init__(self, *args, **kwargs) -> None: def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: """List the operations for the provider. - :return: An iterator like instance of Operation + :return: An iterator like instance of either Operation or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.databasewatcher.models.Operation] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[List[_models.Operation]] = kwargs.pop("cls", None) - - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_operations_list_request( - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - return _request - - async def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.Operation], deserialized["value"]) - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - -class WatchersOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.databasewatcher.aio.DatabaseWatcherMgmtClient`'s - :attr:`watchers` attribute. - """ - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: DatabaseWatcherMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async - async def get(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> _models.Watcher: - """Get a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: Watcher. The Watcher is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.Watcher - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) - - _request = build_watchers_get_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - if _stream: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() - else: - deserialized = _deserialize(_models.Watcher, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - async def _create_or_update_initial( - self, - resource_group_name: str, - watcher_name: str, - resource: Union[_models.Watcher, JSON, IO[bytes]], - **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _content = None - if isinstance(resource, (IOBase, bytes)): - _content = resource - else: - _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore - - _request = build_watchers_create_or_update_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - content_type=content_type, - api_version=self._config.api_version, - content=_content, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 201: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - watcher_name: str, - resource: _models.Watcher, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Watcher]: - """Create a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param resource: Resource create parameters. Required. - :type resource: ~azure.mgmt.databasewatcher.models.Watcher - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - watcher_name: str, - resource: JSON, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Watcher]: - """Create a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param resource: Resource create parameters. Required. - :type resource: JSON - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - watcher_name: str, - resource: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Watcher]: - """Create a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param resource: Resource create parameters. Required. - :type resource: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_create_or_update( - self, - resource_group_name: str, - watcher_name: str, - resource: Union[_models.Watcher, JSON, IO[bytes]], - **kwargs: Any - ) -> AsyncLROPoller[_models.Watcher]: - """Create a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param resource: Resource create parameters. Is one of the following types: Watcher, JSON, - IO[bytes] Required. - :type resource: ~azure.mgmt.databasewatcher.models.Watcher or JSON or IO[bytes] - :return: An instance of AsyncLROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._create_or_update_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - resource=resource, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - response = pipeline_response.http_response - deserialized = _deserialize(_models.Watcher, response.json()) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: AsyncPollingMethod = cast( - AsyncPollingMethod, AsyncARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.Watcher].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.Watcher]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - async def _update_initial( - self, - resource_group_name: str, - watcher_name: str, - properties: Union[_models.WatcherUpdate, JSON, IO[bytes]], - **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _content = json.dumps(properties, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore - - _request = build_watchers_update_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - content_type=content_type, - api_version=self._config.api_version, - content=_content, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_update( - self, - resource_group_name: str, - watcher_name: str, - properties: _models.WatcherUpdate, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Watcher]: - """Update a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param properties: The resource properties to be updated. Required. - :type properties: ~azure.mgmt.databasewatcher.models.WatcherUpdate - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_update( - self, - resource_group_name: str, - watcher_name: str, - properties: JSON, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Watcher]: - """Update a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param properties: The resource properties to be updated. Required. - :type properties: JSON - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_update( - self, - resource_group_name: str, - watcher_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.Watcher]: - """Update a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param properties: The resource properties to be updated. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_update( - self, - resource_group_name: str, - watcher_name: str, - properties: Union[_models.WatcherUpdate, JSON, IO[bytes]], - **kwargs: Any - ) -> AsyncLROPoller[_models.Watcher]: - """Update a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param properties: The resource properties to be updated. Is one of the following types: - WatcherUpdate, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.databasewatcher.models.WatcherUpdate or JSON or IO[bytes] - :return: An instance of AsyncLROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._update_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - properties=properties, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - response = pipeline_response.http_response - deserialized = _deserialize(_models.Watcher, response.json()) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: AsyncPollingMethod = cast( - AsyncPollingMethod, AsyncARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.Watcher].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.Watcher]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - async def _delete_initial(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_watchers_delete_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202, 204]: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> AsyncLROPoller[None]: - """Delete a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: An instance of AsyncLROPoller that returns None - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: AsyncPollingMethod = cast( - AsyncPollingMethod, AsyncARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> AsyncIterable["_models.Watcher"]: - """List Watcher resources by resource group. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :return: An iterator like instance of Watcher - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[List[_models.Watcher]] = kwargs.pop("cls", None) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) error_map: MutableMapping = { 401: ClientAuthenticationError, @@ -856,19 +78,12 @@ def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Asy def prepare_request(next_link=None): if not next_link: - _request = build_watchers_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, + _request = build_list_request( + api_version=api_version, headers=_headers, params=_params, ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -883,2123 +98,16 @@ def prepare_request(next_link=None): _request = HttpRequest( "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - return _request - - async def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.Watcher], deserialized["value"]) - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.Watcher"]: - """List Watcher resources by subscription ID. - - :return: An iterator like instance of Watcher - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[List[_models.Watcher]] = kwargs.pop("cls", None) - - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_watchers_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - return _request - - async def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.Watcher], deserialized["value"]) - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - async def _start_initial(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_watchers_start_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_start(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> AsyncLROPoller[None]: - """The action to start monitoring all targets configured for a database watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: An instance of AsyncLROPoller that returns None - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._start_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: AsyncPollingMethod = cast( - AsyncPollingMethod, AsyncARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - async def _stop_initial(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> AsyncIterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_watchers_stop_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_stop(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> AsyncLROPoller[None]: - """The action to stop monitoring all targets configured for a database watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: An instance of AsyncLROPoller that returns None - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._stop_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: AsyncPollingMethod = cast( - AsyncPollingMethod, AsyncARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - -class AlertRuleResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.databasewatcher.aio.DatabaseWatcherMgmtClient`'s - :attr:`alert_rule_resources` attribute. - """ - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: DatabaseWatcherMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async - @api_version_validation( - method_added_on="2024-07-19-preview", - params_added_on={ - "2024-07-19-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "watcher_name", - "alert_rule_resource_name", - "accept", - ] - }, - ) - async def get( - self, resource_group_name: str, watcher_name: str, alert_rule_resource_name: str, **kwargs: Any - ) -> _models.AlertRuleResource: - """Get a AlertRuleResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param alert_rule_resource_name: The alert rule proxy resource name. Required. - :type alert_rule_resource_name: str - :return: AlertRuleResource. The AlertRuleResource is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.AlertRuleResource] = kwargs.pop("cls", None) - - _request = build_alert_rule_resources_get_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - alert_rule_resource_name=alert_rule_resource_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - if _stream: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() - else: - deserialized = _deserialize(_models.AlertRuleResource, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - alert_rule_resource_name: str, - resource: _models.AlertRuleResource, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.AlertRuleResource: - """Create a AlertRuleResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param alert_rule_resource_name: The alert rule proxy resource name. Required. - :type alert_rule_resource_name: str - :param resource: Resource create parameters. Required. - :type resource: ~azure.mgmt.databasewatcher.models.AlertRuleResource - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: AlertRuleResource. The AlertRuleResource is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - alert_rule_resource_name: str, - resource: JSON, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.AlertRuleResource: - """Create a AlertRuleResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param alert_rule_resource_name: The alert rule proxy resource name. Required. - :type alert_rule_resource_name: str - :param resource: Resource create parameters. Required. - :type resource: JSON - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: AlertRuleResource. The AlertRuleResource is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - alert_rule_resource_name: str, - resource: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.AlertRuleResource: - """Create a AlertRuleResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param alert_rule_resource_name: The alert rule proxy resource name. Required. - :type alert_rule_resource_name: str - :param resource: Resource create parameters. Required. - :type resource: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: AlertRuleResource. The AlertRuleResource is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - @api_version_validation( - method_added_on="2024-07-19-preview", - params_added_on={ - "2024-07-19-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "watcher_name", - "alert_rule_resource_name", - "content_type", - "accept", - ] - }, - ) - async def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - alert_rule_resource_name: str, - resource: Union[_models.AlertRuleResource, JSON, IO[bytes]], - **kwargs: Any - ) -> _models.AlertRuleResource: - """Create a AlertRuleResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param alert_rule_resource_name: The alert rule proxy resource name. Required. - :type alert_rule_resource_name: str - :param resource: Resource create parameters. Is one of the following types: AlertRuleResource, - JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.databasewatcher.models.AlertRuleResource or JSON or IO[bytes] - :return: AlertRuleResource. The AlertRuleResource is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.AlertRuleResource] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _content = None - if isinstance(resource, (IOBase, bytes)): - _content = resource - else: - _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore - - _request = build_alert_rule_resources_create_or_update_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - alert_rule_resource_name=alert_rule_resource_name, - subscription_id=self._config.subscription_id, - content_type=content_type, - api_version=self._config.api_version, - content=_content, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - if _stream: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() - else: - deserialized = _deserialize(_models.AlertRuleResource, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - @api_version_validation( - method_added_on="2024-07-19-preview", - params_added_on={ - "2024-07-19-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "watcher_name", - "alert_rule_resource_name", - "accept", - ] - }, - ) - async def delete( - self, resource_group_name: str, watcher_name: str, alert_rule_resource_name: str, **kwargs: Any - ) -> None: - """Delete a AlertRuleResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param alert_rule_resource_name: The alert rule proxy resource name. Required. - :type alert_rule_resource_name: str - :return: None - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_alert_rule_resources_delete_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - alert_rule_resource_name=alert_rule_resource_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace - @api_version_validation( - method_added_on="2024-07-19-preview", - params_added_on={ - "2024-07-19-preview": ["api_version", "subscription_id", "resource_group_name", "watcher_name", "accept"] - }, - ) - def list_by_parent( - self, resource_group_name: str, watcher_name: str, **kwargs: Any - ) -> AsyncIterable["_models.AlertRuleResource"]: - """List AlertRuleResource resources by Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: An iterator like instance of AlertRuleResource - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.databasewatcher.models.AlertRuleResource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[List[_models.AlertRuleResource]] = kwargs.pop("cls", None) - - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_alert_rule_resources_list_by_parent_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - return _request - - async def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.AlertRuleResource], deserialized["value"]) - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - -class HealthValidationsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.databasewatcher.aio.DatabaseWatcherMgmtClient`'s - :attr:`health_validations` attribute. - """ - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: DatabaseWatcherMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async - @api_version_validation( - method_added_on="2024-10-01-preview", - params_added_on={ - "2024-10-01-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "watcher_name", - "health_validation_name", - "accept", - ] - }, - ) - async def get( - self, resource_group_name: str, watcher_name: str, health_validation_name: str, **kwargs: Any - ) -> _models.HealthValidation: - """Get a HealthValidation. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param health_validation_name: The health validation resource name. Required. - :type health_validation_name: str - :return: HealthValidation. The HealthValidation is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.HealthValidation - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.HealthValidation] = kwargs.pop("cls", None) - - _request = build_health_validations_get_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - health_validation_name=health_validation_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - if _stream: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() - else: - deserialized = _deserialize(_models.HealthValidation, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - @api_version_validation( - method_added_on="2024-10-01-preview", - params_added_on={ - "2024-10-01-preview": ["api_version", "subscription_id", "resource_group_name", "watcher_name", "accept"] - }, - ) - def list_by_parent( - self, resource_group_name: str, watcher_name: str, **kwargs: Any - ) -> AsyncIterable["_models.HealthValidation"]: - """List HealthValidation resources by Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: An iterator like instance of HealthValidation - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.databasewatcher.models.HealthValidation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[List[_models.HealthValidation]] = kwargs.pop("cls", None) - - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_health_validations_list_by_parent_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - return _request - - async def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.HealthValidation], deserialized["value"]) - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @api_version_validation( - method_added_on="2024-10-01-preview", - params_added_on={ - "2024-10-01-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "watcher_name", - "health_validation_name", - "accept", - ] - }, - ) - async def _start_validation_initial( - self, resource_group_name: str, watcher_name: str, health_validation_name: str, **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_health_validations_start_validation_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - health_validation_name=health_validation_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - @api_version_validation( - method_added_on="2024-10-01-preview", - params_added_on={ - "2024-10-01-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "watcher_name", - "health_validation_name", - "accept", - ] - }, - ) - async def begin_start_validation( - self, resource_group_name: str, watcher_name: str, health_validation_name: str, **kwargs: Any - ) -> AsyncLROPoller[_models.HealthValidation]: - """Starts health validation for a watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param health_validation_name: The health validation resource name. Required. - :type health_validation_name: str - :return: An instance of AsyncLROPoller that returns HealthValidation. The HealthValidation is - compatible with MutableMapping - :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.HealthValidation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.HealthValidation] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._start_validation_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - health_validation_name=health_validation_name, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - response_headers = {} - response = pipeline_response.http_response - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = _deserialize(_models.HealthValidation, response.json()) - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - return deserialized - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: AsyncPollingMethod = cast( - AsyncPollingMethod, AsyncARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.HealthValidation].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.HealthValidation]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - -class TargetsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.databasewatcher.aio.DatabaseWatcherMgmtClient`'s - :attr:`targets` attribute. - """ - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: DatabaseWatcherMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async - async def get(self, resource_group_name: str, watcher_name: str, target_name: str, **kwargs: Any) -> _models.Target: - """Get a Target. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param target_name: The target resource name. Required. - :type target_name: str - :return: Target. The Target is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.Target - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.Target] = kwargs.pop("cls", None) - - _request = build_targets_get_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - target_name=target_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - if _stream: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() - else: - deserialized = _deserialize(_models.Target, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - async def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - target_name: str, - resource: _models.Target, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Target: - """Create a Target. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param target_name: The target resource name. Required. - :type target_name: str - :param resource: Resource create parameters. Required. - :type resource: ~azure.mgmt.databasewatcher.models.Target - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Target. The Target is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.Target - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - target_name: str, - resource: JSON, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Target: - """Create a Target. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param target_name: The target resource name. Required. - :type target_name: str - :param resource: Resource create parameters. Required. - :type resource: JSON - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Target. The Target is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.Target - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - target_name: str, - resource: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Target: - """Create a Target. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param target_name: The target resource name. Required. - :type target_name: str - :param resource: Resource create parameters. Required. - :type resource: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Target. The Target is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.Target - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - target_name: str, - resource: Union[_models.Target, JSON, IO[bytes]], - **kwargs: Any - ) -> _models.Target: - """Create a Target. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param target_name: The target resource name. Required. - :type target_name: str - :param resource: Resource create parameters. Is one of the following types: Target, JSON, - IO[bytes] Required. - :type resource: ~azure.mgmt.databasewatcher.models.Target or JSON or IO[bytes] - :return: Target. The Target is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.Target - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Target] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _content = None - if isinstance(resource, (IOBase, bytes)): - _content = resource - else: - _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore - - _request = build_targets_create_or_update_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - target_name=target_name, - subscription_id=self._config.subscription_id, - content_type=content_type, - api_version=self._config.api_version, - content=_content, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - if _stream: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() - else: - deserialized = _deserialize(_models.Target, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def delete(self, resource_group_name: str, watcher_name: str, target_name: str, **kwargs: Any) -> None: - """Delete a Target. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param target_name: The target resource name. Required. - :type target_name: str - :return: None - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_targets_delete_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - target_name=target_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace - def list_by_watcher( - self, resource_group_name: str, watcher_name: str, **kwargs: Any - ) -> AsyncIterable["_models.Target"]: - """List Target resources by Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: An iterator like instance of Target - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.databasewatcher.models.Target] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[List[_models.Target]] = kwargs.pop("cls", None) - - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_targets_list_by_watcher_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - return _request - - async def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.Target], deserialized["value"]) - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - -class SharedPrivateLinkResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.databasewatcher.aio.DatabaseWatcherMgmtClient`'s - :attr:`shared_private_link_resources` attribute. - """ - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: DatabaseWatcherMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async - async def get( - self, resource_group_name: str, watcher_name: str, shared_private_link_resource_name: str, **kwargs: Any - ) -> _models.SharedPrivateLinkResource: - """Get a SharedPrivateLinkResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param shared_private_link_resource_name: The Shared Private Link resource name. Required. - :type shared_private_link_resource_name: str - :return: SharedPrivateLinkResource. The SharedPrivateLinkResource is compatible with - MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.SharedPrivateLinkResource] = kwargs.pop("cls", None) - - _request = build_shared_private_link_resources_get_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - shared_private_link_resource_name=shared_private_link_resource_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - if _stream: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() - else: - deserialized = _deserialize(_models.SharedPrivateLinkResource, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - async def _create_initial( - self, - resource_group_name: str, - watcher_name: str, - shared_private_link_resource_name: str, - resource: Union[_models.SharedPrivateLinkResource, JSON, IO[bytes]], - **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _content = None - if isinstance(resource, (IOBase, bytes)): - _content = resource - else: - _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore - - _request = build_shared_private_link_resources_create_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - shared_private_link_resource_name=shared_private_link_resource_name, - subscription_id=self._config.subscription_id, - content_type=content_type, - api_version=self._config.api_version, - content=_content, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 201: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_create( - self, - resource_group_name: str, - watcher_name: str, - shared_private_link_resource_name: str, - resource: _models.SharedPrivateLinkResource, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.SharedPrivateLinkResource]: - """Create a SharedPrivateLinkResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param shared_private_link_resource_name: The Shared Private Link resource name. Required. - :type shared_private_link_resource_name: str - :param resource: Resource create parameters. Required. - :type resource: ~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns SharedPrivateLinkResource. The - SharedPrivateLinkResource is compatible with MutableMapping - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create( - self, - resource_group_name: str, - watcher_name: str, - shared_private_link_resource_name: str, - resource: JSON, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.SharedPrivateLinkResource]: - """Create a SharedPrivateLinkResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param shared_private_link_resource_name: The Shared Private Link resource name. Required. - :type shared_private_link_resource_name: str - :param resource: Resource create parameters. Required. - :type resource: JSON - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns SharedPrivateLinkResource. The - SharedPrivateLinkResource is compatible with MutableMapping - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create( - self, - resource_group_name: str, - watcher_name: str, - shared_private_link_resource_name: str, - resource: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> AsyncLROPoller[_models.SharedPrivateLinkResource]: - """Create a SharedPrivateLinkResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param shared_private_link_resource_name: The Shared Private Link resource name. Required. - :type shared_private_link_resource_name: str - :param resource: Resource create parameters. Required. - :type resource: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of AsyncLROPoller that returns SharedPrivateLinkResource. The - SharedPrivateLinkResource is compatible with MutableMapping - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def begin_create( - self, - resource_group_name: str, - watcher_name: str, - shared_private_link_resource_name: str, - resource: Union[_models.SharedPrivateLinkResource, JSON, IO[bytes]], - **kwargs: Any - ) -> AsyncLROPoller[_models.SharedPrivateLinkResource]: - """Create a SharedPrivateLinkResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param shared_private_link_resource_name: The Shared Private Link resource name. Required. - :type shared_private_link_resource_name: str - :param resource: Resource create parameters. Is one of the following types: - SharedPrivateLinkResource, JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource or JSON or - IO[bytes] - :return: An instance of AsyncLROPoller that returns SharedPrivateLinkResource. The - SharedPrivateLinkResource is compatible with MutableMapping - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.SharedPrivateLinkResource] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._create_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - shared_private_link_resource_name=shared_private_link_resource_name, - resource=resource, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - response = pipeline_response.http_response - deserialized = _deserialize(_models.SharedPrivateLinkResource, response.json()) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: AsyncPollingMethod = cast( - AsyncPollingMethod, AsyncARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.SharedPrivateLinkResource].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.SharedPrivateLinkResource]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - async def _delete_initial( - self, resource_group_name: str, watcher_name: str, shared_private_link_resource_name: str, **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_shared_private_link_resources_delete_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - shared_private_link_resource_name=shared_private_link_resource_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202, 204]: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def begin_delete( - self, resource_group_name: str, watcher_name: str, shared_private_link_resource_name: str, **kwargs: Any - ) -> AsyncLROPoller[None]: - """Delete a SharedPrivateLinkResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param shared_private_link_resource_name: The Shared Private Link resource name. Required. - :type shared_private_link_resource_name: str - :return: An instance of AsyncLROPoller that returns None - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - shared_private_link_resource_name=shared_private_link_resource_name, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: AsyncPollingMethod = cast( - AsyncPollingMethod, AsyncARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list_by_watcher( - self, resource_group_name: str, watcher_name: str, **kwargs: Any - ) -> AsyncIterable["_models.SharedPrivateLinkResource"]: - """List SharedPrivateLinkResource resources by Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: An iterator like instance of SharedPrivateLinkResource - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[List[_models.SharedPrivateLinkResource]] = kwargs.pop("cls", None) - - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_shared_private_link_resources_list_by_watcher_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - + _request.url = self._client.format_url(_request.url) + _request.method = "GET" return _request async def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.SharedPrivateLinkResource], deserialized["value"]) + deserialized = self._deserialize("OperationListResult", pipeline_response) + list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, AsyncList(list_of_elem) + return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): _request = prepare_request(next_link) @@ -3012,7 +120,7 @@ async def get_next(next_link=None): if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) return pipeline_response diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_shared_private_link_resources_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_shared_private_link_resources_operations.py new file mode 100644 index 000000000000..d5fd7a4bc7a5 --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_shared_private_link_resources_operations.py @@ -0,0 +1,544 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from collections.abc import MutableMapping +from io import IOBase +from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse + +from azure.core import AsyncPipelineClient +from azure.core.async_paging import AsyncItemPaged, AsyncList +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, + map_error, +) +from azure.core.pipeline import PipelineResponse +from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod +from azure.core.rest import AsyncHttpResponse, HttpRequest +from azure.core.tracing.decorator import distributed_trace +from azure.core.tracing.decorator_async import distributed_trace_async +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat +from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling + +from ... import models as _models +from ..._utils.serialization import Deserializer, Serializer +from ...operations._shared_private_link_resources_operations import ( + build_create_request, + build_delete_request, + build_get_request, + build_list_by_watcher_request, +) +from .._configuration import MicrosoftDatabaseWatcherConfiguration + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + + +class SharedPrivateLinkResourcesOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.databasewatcher.aio.MicrosoftDatabaseWatcher`'s + :attr:`shared_private_link_resources` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: MicrosoftDatabaseWatcherConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def list_by_watcher( + self, resource_group_name: str, watcher_name: str, **kwargs: Any + ) -> AsyncIterable["_models.SharedPrivateLinkResource"]: + """List SharedPrivateLinkResource resources by Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: An iterator like instance of either SharedPrivateLinkResource or the result of + cls(response) + :rtype: + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.SharedPrivateLinkResourceListResult] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_list_by_watcher_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request + + async def extract_data(pipeline_response): + deserialized = self._deserialize("SharedPrivateLinkResourceListResult", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.next_link or None, AsyncList(list_of_elem) + + async def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return AsyncItemPaged(get_next, extract_data) + + @distributed_trace_async + async def get( + self, resource_group_name: str, watcher_name: str, shared_private_link_resource_name: str, **kwargs: Any + ) -> _models.SharedPrivateLinkResource: + """Get a SharedPrivateLinkResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param shared_private_link_resource_name: The Shared Private Link resource name. Required. + :type shared_private_link_resource_name: str + :return: SharedPrivateLinkResource or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.SharedPrivateLinkResource] = kwargs.pop("cls", None) + + _request = build_get_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + shared_private_link_resource_name=shared_private_link_resource_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("SharedPrivateLinkResource", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + async def _create_initial( + self, + resource_group_name: str, + watcher_name: str, + shared_private_link_resource_name: str, + resource: Union[_models.SharedPrivateLinkResource, IO[bytes]], + **kwargs: Any + ) -> AsyncIterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(resource, (IOBase, bytes)): + _content = resource + else: + _json = self._serialize.body(resource, "SharedPrivateLinkResource") + + _request = build_create_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + shared_private_link_resource_name=shared_private_link_resource_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 201: + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @overload + async def begin_create( + self, + resource_group_name: str, + watcher_name: str, + shared_private_link_resource_name: str, + resource: _models.SharedPrivateLinkResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[_models.SharedPrivateLinkResource]: + """Create a SharedPrivateLinkResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param shared_private_link_resource_name: The Shared Private Link resource name. Required. + :type shared_private_link_resource_name: str + :param resource: Resource create parameters. Required. + :type resource: ~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: An instance of AsyncLROPoller that returns either SharedPrivateLinkResource or the + result of cls(response) + :rtype: + ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def begin_create( + self, + resource_group_name: str, + watcher_name: str, + shared_private_link_resource_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[_models.SharedPrivateLinkResource]: + """Create a SharedPrivateLinkResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param shared_private_link_resource_name: The Shared Private Link resource name. Required. + :type shared_private_link_resource_name: str + :param resource: Resource create parameters. Required. + :type resource: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: An instance of AsyncLROPoller that returns either SharedPrivateLinkResource or the + result of cls(response) + :rtype: + ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def begin_create( + self, + resource_group_name: str, + watcher_name: str, + shared_private_link_resource_name: str, + resource: Union[_models.SharedPrivateLinkResource, IO[bytes]], + **kwargs: Any + ) -> AsyncLROPoller[_models.SharedPrivateLinkResource]: + """Create a SharedPrivateLinkResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param shared_private_link_resource_name: The Shared Private Link resource name. Required. + :type shared_private_link_resource_name: str + :param resource: Resource create parameters. Is either a SharedPrivateLinkResource type or a + IO[bytes] type. Required. + :type resource: ~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource or IO[bytes] + :return: An instance of AsyncLROPoller that returns either SharedPrivateLinkResource or the + result of cls(response) + :rtype: + ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.SharedPrivateLinkResource] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = await self._create_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + shared_private_link_resource_name=shared_private_link_resource_name, + resource=resource, + api_version=api_version, + content_type=content_type, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + await raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): + deserialized = self._deserialize("SharedPrivateLinkResource", pipeline_response.http_response) + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + return deserialized + + if polling is True: + polling_method: AsyncPollingMethod = cast( + AsyncPollingMethod, + AsyncARMPolling(lro_delay, lro_options={"final-state-via": "azure-async-operation"}, **kwargs), + ) + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling + if cont_token: + return AsyncLROPoller[_models.SharedPrivateLinkResource].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return AsyncLROPoller[_models.SharedPrivateLinkResource]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) + + async def _delete_initial( + self, resource_group_name: str, watcher_name: str, shared_private_link_resource_name: str, **kwargs: Any + ) -> AsyncIterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) + + _request = build_delete_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + shared_private_link_resource_name=shared_private_link_resource_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202, 204]: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 202: + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def begin_delete( + self, resource_group_name: str, watcher_name: str, shared_private_link_resource_name: str, **kwargs: Any + ) -> AsyncLROPoller[None]: + """Delete a SharedPrivateLinkResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param shared_private_link_resource_name: The Shared Private Link resource name. Required. + :type shared_private_link_resource_name: str + :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[None] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[None] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = await self._delete_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + shared_private_link_resource_name=shared_private_link_resource_name, + api_version=api_version, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + await raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements + if cls: + return cls(pipeline_response, None, {}) # type: ignore + + if polling is True: + polling_method: AsyncPollingMethod = cast( + AsyncPollingMethod, AsyncARMPolling(lro_delay, lro_options={"final-state-via": "location"}, **kwargs) + ) + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling + if cont_token: + return AsyncLROPoller[None].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_targets_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_targets_operations.py new file mode 100644 index 000000000000..b5213d413186 --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_targets_operations.py @@ -0,0 +1,400 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from collections.abc import MutableMapping +from io import IOBase +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +import urllib.parse + +from azure.core import AsyncPipelineClient +from azure.core.async_paging import AsyncItemPaged, AsyncList +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) +from azure.core.pipeline import PipelineResponse +from azure.core.rest import AsyncHttpResponse, HttpRequest +from azure.core.tracing.decorator import distributed_trace +from azure.core.tracing.decorator_async import distributed_trace_async +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat + +from ... import models as _models +from ..._utils.serialization import Deserializer, Serializer +from ...operations._targets_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_watcher_request, +) +from .._configuration import MicrosoftDatabaseWatcherConfiguration + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + + +class TargetsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.databasewatcher.aio.MicrosoftDatabaseWatcher`'s + :attr:`targets` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: MicrosoftDatabaseWatcherConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def list_by_watcher( + self, resource_group_name: str, watcher_name: str, **kwargs: Any + ) -> AsyncIterable["_models.Target"]: + """List Target resources by Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: An iterator like instance of either Target or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.databasewatcher.models.Target] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.TargetListResult] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_list_by_watcher_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request + + async def extract_data(pipeline_response): + deserialized = self._deserialize("TargetListResult", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.next_link or None, AsyncList(list_of_elem) + + async def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return AsyncItemPaged(get_next, extract_data) + + @distributed_trace_async + async def get(self, resource_group_name: str, watcher_name: str, target_name: str, **kwargs: Any) -> _models.Target: + """Get a Target. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param target_name: The target resource name. Required. + :type target_name: str + :return: Target or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.Target + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.Target] = kwargs.pop("cls", None) + + _request = build_get_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + target_name=target_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("Target", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @overload + async def create_or_update( + self, + resource_group_name: str, + watcher_name: str, + target_name: str, + resource: _models.Target, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Target: + """Create a Target. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param target_name: The target resource name. Required. + :type target_name: str + :param resource: Resource create parameters. Required. + :type resource: ~azure.mgmt.databasewatcher.models.Target + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: Target or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.Target + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + watcher_name: str, + target_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Target: + """Create a Target. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param target_name: The target resource name. Required. + :type target_name: str + :param resource: Resource create parameters. Required. + :type resource: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: Target or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.Target + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + watcher_name: str, + target_name: str, + resource: Union[_models.Target, IO[bytes]], + **kwargs: Any + ) -> _models.Target: + """Create a Target. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param target_name: The target resource name. Required. + :type target_name: str + :param resource: Resource create parameters. Is either a Target type or a IO[bytes] type. + Required. + :type resource: ~azure.mgmt.databasewatcher.models.Target or IO[bytes] + :return: Target or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.Target + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.Target] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(resource, (IOBase, bytes)): + _content = resource + else: + _json = self._serialize.body(resource, "Target") + + _request = build_create_or_update_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + target_name=target_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("Target", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def delete(self, resource_group_name: str, watcher_name: str, target_name: str, **kwargs: Any) -> None: + """Delete a Target. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param target_name: The target resource name. Required. + :type target_name: str + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_delete_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + target_name=target_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 204]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if cls: + return cls(pipeline_response, None, {}) # type: ignore diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_watchers_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_watchers_operations.py new file mode 100644 index 000000000000..90d990ddc6d7 --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/aio/operations/_watchers_operations.py @@ -0,0 +1,1015 @@ +# pylint: disable=too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from collections.abc import MutableMapping +from io import IOBase +from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse + +from azure.core import AsyncPipelineClient +from azure.core.async_paging import AsyncItemPaged, AsyncList +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, + map_error, +) +from azure.core.pipeline import PipelineResponse +from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod +from azure.core.rest import AsyncHttpResponse, HttpRequest +from azure.core.tracing.decorator import distributed_trace +from azure.core.tracing.decorator_async import distributed_trace_async +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat +from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling + +from ... import models as _models +from ..._utils.serialization import Deserializer, Serializer +from ...operations._watchers_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_resource_group_request, + build_list_by_subscription_request, + build_start_request, + build_stop_request, + build_update_request, +) +from .._configuration import MicrosoftDatabaseWatcherConfiguration + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + + +class WatchersOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.databasewatcher.aio.MicrosoftDatabaseWatcher`'s + :attr:`watchers` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: MicrosoftDatabaseWatcherConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.Watcher"]: + """List Watcher resources by subscription ID. + + :return: An iterator like instance of either Watcher or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.WatcherListResult] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_list_by_subscription_request( + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request + + async def extract_data(pipeline_response): + deserialized = self._deserialize("WatcherListResult", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.next_link or None, AsyncList(list_of_elem) + + async def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return AsyncItemPaged(get_next, extract_data) + + @distributed_trace + def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> AsyncIterable["_models.Watcher"]: + """List Watcher resources by resource group. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :return: An iterator like instance of either Watcher or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.WatcherListResult] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_list_by_resource_group_request( + resource_group_name=resource_group_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request + + async def extract_data(pipeline_response): + deserialized = self._deserialize("WatcherListResult", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.next_link or None, AsyncList(list_of_elem) + + async def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return AsyncItemPaged(get_next, extract_data) + + @distributed_trace_async + async def get(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> _models.Watcher: + """Get a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: Watcher or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.Watcher + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) + + _request = build_get_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("Watcher", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + async def _create_or_update_initial( + self, resource_group_name: str, watcher_name: str, resource: Union[_models.Watcher, IO[bytes]], **kwargs: Any + ) -> AsyncIterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(resource, (IOBase, bytes)): + _content = resource + else: + _json = self._serialize.body(resource, "Watcher") + + _request = build_create_or_update_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 201: + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + watcher_name: str, + resource: _models.Watcher, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[_models.Watcher]: + """Create a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param resource: Resource create parameters. Required. + :type resource: ~azure.mgmt.databasewatcher.models.Watcher + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: An instance of AsyncLROPoller that returns either Watcher or the result of + cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + watcher_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[_models.Watcher]: + """Create a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param resource: Resource create parameters. Required. + :type resource: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: An instance of AsyncLROPoller that returns either Watcher or the result of + cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def begin_create_or_update( + self, resource_group_name: str, watcher_name: str, resource: Union[_models.Watcher, IO[bytes]], **kwargs: Any + ) -> AsyncLROPoller[_models.Watcher]: + """Create a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param resource: Resource create parameters. Is either a Watcher type or a IO[bytes] type. + Required. + :type resource: ~azure.mgmt.databasewatcher.models.Watcher or IO[bytes] + :return: An instance of AsyncLROPoller that returns either Watcher or the result of + cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = await self._create_or_update_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + resource=resource, + api_version=api_version, + content_type=content_type, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + await raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): + deserialized = self._deserialize("Watcher", pipeline_response.http_response) + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + return deserialized + + if polling is True: + polling_method: AsyncPollingMethod = cast( + AsyncPollingMethod, + AsyncARMPolling(lro_delay, lro_options={"final-state-via": "azure-async-operation"}, **kwargs), + ) + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling + if cont_token: + return AsyncLROPoller[_models.Watcher].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return AsyncLROPoller[_models.Watcher]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) + + async def _update_initial( + self, + resource_group_name: str, + watcher_name: str, + properties: Union[_models.WatcherUpdate, IO[bytes]], + **kwargs: Any + ) -> AsyncIterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IOBase, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "WatcherUpdate") + + _request = build_update_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 202]: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 202: + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @overload + async def begin_update( + self, + resource_group_name: str, + watcher_name: str, + properties: _models.WatcherUpdate, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[_models.Watcher]: + """Update a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param properties: The resource properties to be updated. Required. + :type properties: ~azure.mgmt.databasewatcher.models.WatcherUpdate + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: An instance of AsyncLROPoller that returns either Watcher or the result of + cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def begin_update( + self, + resource_group_name: str, + watcher_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[_models.Watcher]: + """Update a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param properties: The resource properties to be updated. Required. + :type properties: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: An instance of AsyncLROPoller that returns either Watcher or the result of + cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def begin_update( + self, + resource_group_name: str, + watcher_name: str, + properties: Union[_models.WatcherUpdate, IO[bytes]], + **kwargs: Any + ) -> AsyncLROPoller[_models.Watcher]: + """Update a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param properties: The resource properties to be updated. Is either a WatcherUpdate type or a + IO[bytes] type. Required. + :type properties: ~azure.mgmt.databasewatcher.models.WatcherUpdate or IO[bytes] + :return: An instance of AsyncLROPoller that returns either Watcher or the result of + cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = await self._update_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + properties=properties, + api_version=api_version, + content_type=content_type, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + await raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): + deserialized = self._deserialize("Watcher", pipeline_response.http_response) + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + return deserialized + + if polling is True: + polling_method: AsyncPollingMethod = cast( + AsyncPollingMethod, AsyncARMPolling(lro_delay, lro_options={"final-state-via": "location"}, **kwargs) + ) + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling + if cont_token: + return AsyncLROPoller[_models.Watcher].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return AsyncLROPoller[_models.Watcher]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) + + async def _delete_initial(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> AsyncIterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) + + _request = build_delete_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202, 204]: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 202: + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def begin_delete(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> AsyncLROPoller[None]: + """Delete a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[None] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[None] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = await self._delete_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + api_version=api_version, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + await raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements + if cls: + return cls(pipeline_response, None, {}) # type: ignore + + if polling is True: + polling_method: AsyncPollingMethod = cast( + AsyncPollingMethod, AsyncARMPolling(lro_delay, lro_options={"final-state-via": "location"}, **kwargs) + ) + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling + if cont_token: + return AsyncLROPoller[None].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore + + async def _start_initial(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> AsyncIterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) + + _request = build_start_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 202]: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 202: + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def begin_start( + self, resource_group_name: str, watcher_name: str, **kwargs: Any + ) -> AsyncLROPoller[_models.Watcher]: + """The action to start monitoring all targets configured for a database watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: An instance of AsyncLROPoller that returns either Watcher or the result of + cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = await self._start_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + api_version=api_version, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + await raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): + deserialized = self._deserialize("Watcher", pipeline_response.http_response) + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + return deserialized + + if polling is True: + polling_method: AsyncPollingMethod = cast( + AsyncPollingMethod, + AsyncARMPolling(lro_delay, lro_options={"final-state-via": "azure-async-operation"}, **kwargs), + ) + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling + if cont_token: + return AsyncLROPoller[_models.Watcher].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return AsyncLROPoller[_models.Watcher]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) + + async def _stop_initial(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> AsyncIterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) + + _request = build_stop_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 202]: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 202: + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def begin_stop( + self, resource_group_name: str, watcher_name: str, **kwargs: Any + ) -> AsyncLROPoller[_models.Watcher]: + """The action to stop monitoring all targets configured for a database watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: An instance of AsyncLROPoller that returns either Watcher or the result of + cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = await self._stop_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + api_version=api_version, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + await raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): + deserialized = self._deserialize("Watcher", pipeline_response.http_response) + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + return deserialized + + if polling is True: + polling_method: AsyncPollingMethod = cast( + AsyncPollingMethod, + AsyncARMPolling(lro_delay, lro_options={"final-state-via": "azure-async-operation"}, **kwargs), + ) + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling + if cont_token: + return AsyncLROPoller[_models.Watcher].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return AsyncLROPoller[_models.Watcher]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/__init__.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/__init__.py index fdd9b10a3884..fb803a57a8f7 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/__init__.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/__init__.py @@ -2,7 +2,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- # pylint: disable=wrong-import-position @@ -13,39 +13,41 @@ from ._patch import * # pylint: disable=unused-wildcard-import -from ._models import ( # type: ignore +from ._models_py3 import ( # type: ignore AlertRuleResource, - AlertRuleResourceProperties, + AlertRuleResourceListResult, Datastore, + DatastoreUpdate, ErrorAdditionalInfo, ErrorDetail, ErrorResponse, HealthValidation, - HealthValidationProperties, - ManagedServiceIdentityV4, + HealthValidationListResult, + ManagedServiceIdentity, Operation, OperationDisplay, + OperationListResult, ProxyResource, Resource, SharedPrivateLinkResource, - SharedPrivateLinkResourceProperties, + SharedPrivateLinkResourceListResult, SqlDbElasticPoolTargetProperties, SqlDbSingleDatabaseTargetProperties, SqlMiTargetProperties, SystemData, Target, + TargetListResult, TargetProperties, TrackedResource, UserAssignedIdentity, ValidationIssue, VaultSecret, Watcher, - WatcherProperties, + WatcherListResult, WatcherUpdate, - WatcherUpdateProperties, ) -from ._enums import ( # type: ignore +from ._microsoft_database_watcher_enums import ( # type: ignore ActionType, AlertRuleCreationProperties, CreatedByType, @@ -65,34 +67,36 @@ __all__ = [ "AlertRuleResource", - "AlertRuleResourceProperties", + "AlertRuleResourceListResult", "Datastore", + "DatastoreUpdate", "ErrorAdditionalInfo", "ErrorDetail", "ErrorResponse", "HealthValidation", - "HealthValidationProperties", - "ManagedServiceIdentityV4", + "HealthValidationListResult", + "ManagedServiceIdentity", "Operation", "OperationDisplay", + "OperationListResult", "ProxyResource", "Resource", "SharedPrivateLinkResource", - "SharedPrivateLinkResourceProperties", + "SharedPrivateLinkResourceListResult", "SqlDbElasticPoolTargetProperties", "SqlDbSingleDatabaseTargetProperties", "SqlMiTargetProperties", "SystemData", "Target", + "TargetListResult", "TargetProperties", "TrackedResource", "UserAssignedIdentity", "ValidationIssue", "VaultSecret", "Watcher", - "WatcherProperties", + "WatcherListResult", "WatcherUpdate", - "WatcherUpdateProperties", "ActionType", "AlertRuleCreationProperties", "CreatedByType", diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/_enums.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/_microsoft_database_watcher_enums.py similarity index 83% rename from sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/_enums.py rename to sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/_microsoft_database_watcher_enums.py index 468e6fa1734e..22d816c8f6c6 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/_enums.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/_microsoft_database_watcher_enums.py @@ -2,7 +2,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- @@ -11,12 +11,9 @@ class ActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal - only APIs. - """ + """Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.""" INTERNAL = "Internal" - """Actions are for internal-only APIs.""" class AlertRuleCreationProperties(str, Enum, metaclass=CaseInsensitiveEnumMeta): @@ -29,16 +26,12 @@ class AlertRuleCreationProperties(str, Enum, metaclass=CaseInsensitiveEnumMeta): class CreatedByType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The kind of entity that created the resource.""" + """The type of identity that created the resource.""" USER = "User" - """The entity was created by a user.""" APPLICATION = "Application" - """The entity was created by an application.""" MANAGED_IDENTITY = "ManagedIdentity" - """The entity was created by a managed identity.""" KEY = "Key" - """The entity was created by a key.""" class DatabaseWatcherProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): @@ -69,13 +62,9 @@ class ManagedServiceIdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): """ NONE = "None" - """No managed identity.""" SYSTEM_ASSIGNED = "SystemAssigned" - """System assigned managed identity.""" USER_ASSIGNED = "UserAssigned" - """User assigned managed identity.""" - SYSTEM_AND_USER_ASSIGNED = "SystemAssigned, UserAssigned" - """System and user assigned managed identity.""" + SYSTEM_ASSIGNED_USER_ASSIGNED = "SystemAssigned, UserAssigned" class Origin(str, Enum, metaclass=CaseInsensitiveEnumMeta): @@ -84,11 +73,8 @@ class Origin(str, Enum, metaclass=CaseInsensitiveEnumMeta): """ USER = "user" - """Indicates the operation is initiated by a user.""" SYSTEM = "system" - """Indicates the operation is initiated by a system.""" USER_SYSTEM = "user,system" - """Indicates the operation is initiated by a user or system.""" class ResourceProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/_models.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/_models.py deleted file mode 100644 index d88489e1adba..000000000000 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/_models.py +++ /dev/null @@ -1,1324 +0,0 @@ -# pylint: disable=too-many-lines -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -# pylint: disable=useless-super-delegation - -import datetime -from typing import Any, Dict, List, Literal, Mapping, Optional, TYPE_CHECKING, Union, overload - -from .. import _model_base -from .._model_base import rest_discriminator, rest_field - -if TYPE_CHECKING: - from .. import models as _models - - -class Resource(_model_base.Model): - """Common fields that are returned in the response for all Azure Resource Manager resources. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified resource ID for the resource. Ex - - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. # pylint: disable=line-too-long - :vartype id: str - :ivar name: The name of the resource. - :vartype name: str - :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or - "Microsoft.Storage/storageAccounts". - :vartype type: str - :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy - information. - :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData - """ - - id: Optional[str] = rest_field(visibility=["read"]) - """Fully qualified resource ID for the resource. Ex - - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. # pylint: disable=line-too-long""" - name: Optional[str] = rest_field(visibility=["read"]) - """The name of the resource.""" - type: Optional[str] = rest_field(visibility=["read"]) - """The type of the resource. E.g. \"Microsoft.Compute/virtualMachines\" or - \"Microsoft.Storage/storageAccounts\".""" - system_data: Optional["_models.SystemData"] = rest_field(name="systemData", visibility=["read"]) - """Azure Resource Manager metadata containing createdBy and modifiedBy information.""" - - -class ProxyResource(Resource): - """The resource model definition for a Azure Resource Manager proxy resource. It will not have - tags and a location. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified resource ID for the resource. Ex - - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. # pylint: disable=line-too-long - :vartype id: str - :ivar name: The name of the resource. - :vartype name: str - :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or - "Microsoft.Storage/storageAccounts". - :vartype type: str - :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy - information. - :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData - """ - - -class AlertRuleResource(ProxyResource): - """Concrete proxy resource types can be created by aliasing this type using a specific property - type. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified resource ID for the resource. Ex - - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. # pylint: disable=line-too-long - :vartype id: str - :ivar name: The name of the resource. - :vartype name: str - :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or - "Microsoft.Storage/storageAccounts". - :vartype type: str - :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy - information. - :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData - :ivar properties: The resource-specific properties for this resource. - :vartype properties: ~azure.mgmt.databasewatcher.models.AlertRuleResourceProperties - """ - - properties: Optional["_models.AlertRuleResourceProperties"] = rest_field() - """The resource-specific properties for this resource.""" - - @overload - def __init__( - self, - *, - properties: Optional["_models.AlertRuleResourceProperties"] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class AlertRuleResourceProperties(_model_base.Model): - """The generic properties of the alert rule proxy resource. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - - :ivar alert_rule_resource_id: The resource ID of the alert rule resource. Required. - :vartype alert_rule_resource_id: str - :ivar created_with_properties: The properties with which the alert rule resource was created. - Required. Known values are: "CreatedWithActionGroup" and "None". - :vartype created_with_properties: str or - ~azure.mgmt.databasewatcher.models.AlertRuleCreationProperties - :ivar creation_time: The creation time of the alert rule resource. Required. - :vartype creation_time: ~datetime.datetime - :ivar provisioning_state: The provisioning state of the alert rule resource. Known values are: - "Succeeded", "Failed", and "Canceled". - :vartype provisioning_state: str or - ~azure.mgmt.databasewatcher.models.ResourceProvisioningState - :ivar alert_rule_template_id: The template ID associated with alert rule resource. Required. - :vartype alert_rule_template_id: str - :ivar alert_rule_template_version: The alert rule template version. Required. - :vartype alert_rule_template_version: str - """ - - alert_rule_resource_id: str = rest_field(name="alertRuleResourceId") - """The resource ID of the alert rule resource. Required.""" - created_with_properties: Union[str, "_models.AlertRuleCreationProperties"] = rest_field( - name="createdWithProperties" - ) - """The properties with which the alert rule resource was created. Required. Known values are: - \"CreatedWithActionGroup\" and \"None\".""" - creation_time: datetime.datetime = rest_field(name="creationTime", format="rfc3339") - """The creation time of the alert rule resource. Required.""" - provisioning_state: Optional[Union[str, "_models.ResourceProvisioningState"]] = rest_field( - name="provisioningState", visibility=["read"] - ) - """The provisioning state of the alert rule resource. Known values are: \"Succeeded\", \"Failed\", - and \"Canceled\".""" - alert_rule_template_id: str = rest_field(name="alertRuleTemplateId") - """The template ID associated with alert rule resource. Required.""" - alert_rule_template_version: str = rest_field(name="alertRuleTemplateVersion") - """The alert rule template version. Required.""" - - @overload - def __init__( - self, - *, - alert_rule_resource_id: str, - created_with_properties: Union[str, "_models.AlertRuleCreationProperties"], - creation_time: datetime.datetime, - alert_rule_template_id: str, - alert_rule_template_version: str, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class Datastore(_model_base.Model): - """The properties of a data store. - - - :ivar adx_cluster_resource_id: The Azure resource ID of an Azure Data Explorer cluster. - :vartype adx_cluster_resource_id: str - :ivar kusto_cluster_display_name: The Kusto cluster display name. - :vartype kusto_cluster_display_name: str - :ivar kusto_cluster_uri: The Kusto cluster URI. Required. - :vartype kusto_cluster_uri: str - :ivar kusto_data_ingestion_uri: The Kusto data ingestion URI. Required. - :vartype kusto_data_ingestion_uri: str - :ivar kusto_database_name: The name of a Kusto database. Required. - :vartype kusto_database_name: str - :ivar kusto_management_url: The Kusto management URL. Required. - :vartype kusto_management_url: str - :ivar kusto_offering_type: The type of a Kusto offering. Required. Known values are: "adx", - "free", and "fabric". - :vartype kusto_offering_type: str or ~azure.mgmt.databasewatcher.models.KustoOfferingType - """ - - adx_cluster_resource_id: Optional[str] = rest_field(name="adxClusterResourceId") - """The Azure resource ID of an Azure Data Explorer cluster.""" - kusto_cluster_display_name: Optional[str] = rest_field(name="kustoClusterDisplayName") - """The Kusto cluster display name.""" - kusto_cluster_uri: str = rest_field(name="kustoClusterUri") - """The Kusto cluster URI. Required.""" - kusto_data_ingestion_uri: str = rest_field(name="kustoDataIngestionUri") - """The Kusto data ingestion URI. Required.""" - kusto_database_name: str = rest_field(name="kustoDatabaseName") - """The name of a Kusto database. Required.""" - kusto_management_url: str = rest_field(name="kustoManagementUrl") - """The Kusto management URL. Required.""" - kusto_offering_type: Union[str, "_models.KustoOfferingType"] = rest_field(name="kustoOfferingType") - """The type of a Kusto offering. Required. Known values are: \"adx\", \"free\", and \"fabric\".""" - - @overload - def __init__( - self, - *, - kusto_cluster_uri: str, - kusto_data_ingestion_uri: str, - kusto_database_name: str, - kusto_management_url: str, - kusto_offering_type: Union[str, "_models.KustoOfferingType"], - adx_cluster_resource_id: Optional[str] = None, - kusto_cluster_display_name: Optional[str] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class ErrorAdditionalInfo(_model_base.Model): - """The resource management error additional info. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - :ivar type: The additional info type. - :vartype type: str - :ivar info: The additional info. - :vartype info: any - """ - - type: Optional[str] = rest_field(visibility=["read"]) - """The additional info type.""" - info: Optional[Any] = rest_field(visibility=["read"]) - """The additional info.""" - - -class ErrorDetail(_model_base.Model): - """The error detail. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - :ivar code: The error code. - :vartype code: str - :ivar message: The error message. - :vartype message: str - :ivar target: The error target. - :vartype target: str - :ivar details: The error details. - :vartype details: list[~azure.mgmt.databasewatcher.models.ErrorDetail] - :ivar additional_info: The error additional info. - :vartype additional_info: list[~azure.mgmt.databasewatcher.models.ErrorAdditionalInfo] - """ - - code: Optional[str] = rest_field(visibility=["read"]) - """The error code.""" - message: Optional[str] = rest_field(visibility=["read"]) - """The error message.""" - target: Optional[str] = rest_field(visibility=["read"]) - """The error target.""" - details: Optional[List["_models.ErrorDetail"]] = rest_field(visibility=["read"]) - """The error details.""" - additional_info: Optional[List["_models.ErrorAdditionalInfo"]] = rest_field( - name="additionalInfo", visibility=["read"] - ) - """The error additional info.""" - - -class ErrorResponse(_model_base.Model): - """Common error response for all Azure Resource Manager APIs to return error details for failed - operations. - - :ivar error: The error object. - :vartype error: ~azure.mgmt.databasewatcher.models.ErrorDetail - """ - - error: Optional["_models.ErrorDetail"] = rest_field() - """The error object.""" - - @overload - def __init__( - self, - *, - error: Optional["_models.ErrorDetail"] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class HealthValidation(ProxyResource): - """Concrete proxy resource types can be created by aliasing this type using a specific property - type. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified resource ID for the resource. Ex - - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. # pylint: disable=line-too-long - :vartype id: str - :ivar name: The name of the resource. - :vartype name: str - :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or - "Microsoft.Storage/storageAccounts". - :vartype type: str - :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy - information. - :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData - :ivar properties: The resource-specific properties for this resource. - :vartype properties: ~azure.mgmt.databasewatcher.models.HealthValidationProperties - """ - - properties: Optional["_models.HealthValidationProperties"] = rest_field() - """The resource-specific properties for this resource.""" - - @overload - def __init__( - self, - *, - properties: Optional["_models.HealthValidationProperties"] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class HealthValidationProperties(_model_base.Model): - """The generic properties of the health validation resource. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - - :ivar start_time: The start time of health validation, in UTC. Required. - :vartype start_time: ~datetime.datetime - :ivar end_time: The end time of health validation, in UTC. Required. - :vartype end_time: ~datetime.datetime - :ivar status: The current health validation status. Required. Known values are: "NotStarted", - "Running", "Succeeded", "Failed", "Canceled", and "TimedOut". - :vartype status: str or ~azure.mgmt.databasewatcher.models.ValidationStatus - :ivar issues: The list of issues found by health validation. Required. - :vartype issues: list[~azure.mgmt.databasewatcher.models.ValidationIssue] - :ivar provisioning_state: The provisioning state of the health validation resource. Known - values are: "Succeeded", "Failed", and "Canceled". - :vartype provisioning_state: str or - ~azure.mgmt.databasewatcher.models.ResourceProvisioningState - """ - - start_time: datetime.datetime = rest_field(name="startTime", visibility=["read"], format="rfc3339") - """The start time of health validation, in UTC. Required.""" - end_time: datetime.datetime = rest_field(name="endTime", visibility=["read"], format="rfc3339") - """The end time of health validation, in UTC. Required.""" - status: Union[str, "_models.ValidationStatus"] = rest_field(visibility=["read"]) - """The current health validation status. Required. Known values are: \"NotStarted\", \"Running\", - \"Succeeded\", \"Failed\", \"Canceled\", and \"TimedOut\".""" - issues: List["_models.ValidationIssue"] = rest_field(visibility=["read"]) - """The list of issues found by health validation. Required.""" - provisioning_state: Optional[Union[str, "_models.ResourceProvisioningState"]] = rest_field( - name="provisioningState", visibility=["read"] - ) - """The provisioning state of the health validation resource. Known values are: \"Succeeded\", - \"Failed\", and \"Canceled\".""" - - -class ManagedServiceIdentityV4(_model_base.Model): - """Managed service identity (system assigned and/or user assigned identities). - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - - :ivar principal_id: The service principal ID of the system assigned identity. This property - will only be provided for a system assigned identity. - :vartype principal_id: str - :ivar tenant_id: The tenant ID of the system assigned identity. This property will only be - provided for a system assigned identity. - :vartype tenant_id: str - :ivar type: The type of managed identity assigned to this resource. Required. Known values are: - "None", "SystemAssigned", "UserAssigned", and "SystemAssigned, UserAssigned". - :vartype type: str or ~azure.mgmt.databasewatcher.models.ManagedServiceIdentityType - :ivar user_assigned_identities: The identities assigned to this resource by the user. - :vartype user_assigned_identities: dict[str, - ~azure.mgmt.databasewatcher.models.UserAssignedIdentity] - """ - - principal_id: Optional[str] = rest_field(name="principalId", visibility=["read"]) - """The service principal ID of the system assigned identity. This property will only be provided - for a system assigned identity.""" - tenant_id: Optional[str] = rest_field(name="tenantId", visibility=["read"]) - """The tenant ID of the system assigned identity. This property will only be provided for a system - assigned identity.""" - type: Union[str, "_models.ManagedServiceIdentityType"] = rest_field() - """The type of managed identity assigned to this resource. Required. Known values are: \"None\", - \"SystemAssigned\", \"UserAssigned\", and \"SystemAssigned, UserAssigned\".""" - user_assigned_identities: Optional[Dict[str, "_models.UserAssignedIdentity"]] = rest_field( - name="userAssignedIdentities" - ) - """The identities assigned to this resource by the user.""" - - @overload - def __init__( - self, - *, - type: Union[str, "_models.ManagedServiceIdentityType"], - user_assigned_identities: Optional[Dict[str, "_models.UserAssignedIdentity"]] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class Operation(_model_base.Model): - """Details of a REST API operation, returned from the Resource Provider Operations API. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - :ivar name: The name of the operation, as per Resource-Based Access Control (RBAC). Examples: - "Microsoft.Compute/virtualMachines/write", "Microsoft.Compute/virtualMachines/capture/action". - :vartype name: str - :ivar is_data_action: Whether the operation applies to data-plane. This is "true" for - data-plane operations and "false" for Azure Resource Manager/control-plane operations. - :vartype is_data_action: bool - :ivar display: Localized display information for this particular operation. - :vartype display: ~azure.mgmt.databasewatcher.models.OperationDisplay - :ivar origin: The intended executor of the operation; as in Resource Based Access Control - (RBAC) and audit logs UX. Default value is "user,system". Known values are: "user", "system", - and "user,system". - :vartype origin: str or ~azure.mgmt.databasewatcher.models.Origin - :ivar action_type: Extensible enum. Indicates the action type. "Internal" refers to actions - that are for internal only APIs. "Internal" - :vartype action_type: str or ~azure.mgmt.databasewatcher.models.ActionType - """ - - name: Optional[str] = rest_field(visibility=["read"]) - """The name of the operation, as per Resource-Based Access Control (RBAC). Examples: - \"Microsoft.Compute/virtualMachines/write\", - \"Microsoft.Compute/virtualMachines/capture/action\".""" - is_data_action: Optional[bool] = rest_field(name="isDataAction", visibility=["read"]) - """Whether the operation applies to data-plane. This is \"true\" for data-plane operations and - \"false\" for Azure Resource Manager/control-plane operations.""" - display: Optional["_models.OperationDisplay"] = rest_field() - """Localized display information for this particular operation.""" - origin: Optional[Union[str, "_models.Origin"]] = rest_field(visibility=["read"]) - """The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit - logs UX. Default value is \"user,system\". Known values are: \"user\", \"system\", and - \"user,system\".""" - action_type: Optional[Union[str, "_models.ActionType"]] = rest_field(name="actionType", visibility=["read"]) - """Extensible enum. Indicates the action type. \"Internal\" refers to actions that are for - internal only APIs. \"Internal\"""" - - @overload - def __init__( - self, - *, - display: Optional["_models.OperationDisplay"] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class OperationDisplay(_model_base.Model): - """Localized display information for and operation. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - :ivar provider: The localized friendly form of the resource provider name, e.g. "Microsoft - Monitoring Insights" or "Microsoft Compute". - :vartype provider: str - :ivar resource: The localized friendly name of the resource type related to this operation. - E.g. "Virtual Machines" or "Job Schedule Collections". - :vartype resource: str - :ivar operation: The concise, localized friendly name for the operation; suitable for - dropdowns. E.g. "Create or Update Virtual Machine", "Restart Virtual Machine". - :vartype operation: str - :ivar description: The short, localized friendly description of the operation; suitable for - tool tips and detailed views. - :vartype description: str - """ - - provider: Optional[str] = rest_field(visibility=["read"]) - """The localized friendly form of the resource provider name, e.g. \"Microsoft Monitoring - Insights\" or \"Microsoft Compute\".""" - resource: Optional[str] = rest_field(visibility=["read"]) - """The localized friendly name of the resource type related to this operation. E.g. \"Virtual - Machines\" or \"Job Schedule Collections\".""" - operation: Optional[str] = rest_field(visibility=["read"]) - """The concise, localized friendly name for the operation; suitable for dropdowns. E.g. \"Create - or Update Virtual Machine\", \"Restart Virtual Machine\".""" - description: Optional[str] = rest_field(visibility=["read"]) - """The short, localized friendly description of the operation; suitable for tool tips and detailed - views.""" - - -class SharedPrivateLinkResource(ProxyResource): - """Concrete proxy resource types can be created by aliasing this type using a specific property - type. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified resource ID for the resource. Ex - - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. # pylint: disable=line-too-long - :vartype id: str - :ivar name: The name of the resource. - :vartype name: str - :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or - "Microsoft.Storage/storageAccounts". - :vartype type: str - :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy - information. - :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData - :ivar properties: The resource-specific properties for this resource. - :vartype properties: ~azure.mgmt.databasewatcher.models.SharedPrivateLinkResourceProperties - """ - - properties: Optional["_models.SharedPrivateLinkResourceProperties"] = rest_field() - """The resource-specific properties for this resource.""" - - @overload - def __init__( - self, - *, - properties: Optional["_models.SharedPrivateLinkResourceProperties"] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class SharedPrivateLinkResourceProperties(_model_base.Model): - """The generic properties of a Shared Private Link resource. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - - :ivar private_link_resource_id: The resource ID of the resource the shared private link - resource is for. Required. - :vartype private_link_resource_id: str - :ivar group_id: The group id from the provider of resource the shared private link resource is - for. Required. - :vartype group_id: str - :ivar request_message: The request message for requesting approval of the shared private link - resource. Required. - :vartype request_message: str - :ivar dns_zone: The DNS zone to be included in the DNS name of the shared private link. Value - is required for Azure Data Explorer clusters and SQL managed instances. The value to use is the - second segment of the host FQDN name of the resource that the shared private link resource is - for. - :vartype dns_zone: str - :ivar status: Status of the shared private link resource. Can be Pending, Approved, Rejected or - Disconnected. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". - :vartype status: str or ~azure.mgmt.databasewatcher.models.SharedPrivateLinkResourceStatus - :ivar provisioning_state: The provisioning state of the resource. Known values are: - "Succeeded", "Failed", and "Canceled". - :vartype provisioning_state: str or - ~azure.mgmt.databasewatcher.models.ResourceProvisioningState - """ - - private_link_resource_id: str = rest_field(name="privateLinkResourceId") - """The resource ID of the resource the shared private link resource is for. Required.""" - group_id: str = rest_field(name="groupId") - """The group id from the provider of resource the shared private link resource is for. Required.""" - request_message: str = rest_field(name="requestMessage") - """The request message for requesting approval of the shared private link resource. Required.""" - dns_zone: Optional[str] = rest_field(name="dnsZone") - """The DNS zone to be included in the DNS name of the shared private link. Value is required for - Azure Data Explorer clusters and SQL managed instances. The value to use is the second segment - of the host FQDN name of the resource that the shared private link resource is for.""" - status: Optional[Union[str, "_models.SharedPrivateLinkResourceStatus"]] = rest_field(visibility=["read"]) - """Status of the shared private link resource. Can be Pending, Approved, Rejected or Disconnected. - Known values are: \"Pending\", \"Approved\", \"Rejected\", and \"Disconnected\".""" - provisioning_state: Optional[Union[str, "_models.ResourceProvisioningState"]] = rest_field( - name="provisioningState", visibility=["read"] - ) - """The provisioning state of the resource. Known values are: \"Succeeded\", \"Failed\", and - \"Canceled\".""" - - @overload - def __init__( - self, - *, - private_link_resource_id: str, - group_id: str, - request_message: str, - dns_zone: Optional[str] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class TargetProperties(_model_base.Model): - """The generic properties of a target. - - You probably want to use the sub-classes and not this class directly. Known sub-classes are: - SqlDbSingleDatabaseTargetProperties, SqlDbElasticPoolTargetProperties, SqlMiTargetProperties - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - - :ivar target_type: Discriminator property for TargetProperties. Required. Default value is - None. - :vartype target_type: str - :ivar target_authentication_type: The type of authentication to use when connecting to a - target. Required. Known values are: "Aad" and "Sql". - :vartype target_authentication_type: str or - ~azure.mgmt.databasewatcher.models.TargetAuthenticationType - :ivar target_vault: To use SQL authentication when connecting to targets, specify the vault - where the login name and password secrets are stored. - :vartype target_vault: ~azure.mgmt.databasewatcher.models.VaultSecret - :ivar connection_server_name: The server name to use in the connection string when connecting - to a target. Port number and instance name must be specified separately. Required. - :vartype connection_server_name: str - :ivar provisioning_state: The provisioning state of the resource. Known values are: - "Succeeded", "Failed", and "Canceled". - :vartype provisioning_state: str or - ~azure.mgmt.databasewatcher.models.ResourceProvisioningState - """ - - __mapping__: Dict[str, _model_base.Model] = {} - target_type: str = rest_discriminator(name="targetType") - """Discriminator property for TargetProperties. Required. Default value is None.""" - target_authentication_type: Union[str, "_models.TargetAuthenticationType"] = rest_field( - name="targetAuthenticationType" - ) - """The type of authentication to use when connecting to a target. Required. Known values are: - \"Aad\" and \"Sql\".""" - target_vault: Optional["_models.VaultSecret"] = rest_field(name="targetVault") - """To use SQL authentication when connecting to targets, specify the vault where the login name - and password secrets are stored.""" - connection_server_name: str = rest_field(name="connectionServerName") - """The server name to use in the connection string when connecting to a target. Port number and - instance name must be specified separately. Required.""" - provisioning_state: Optional[Union[str, "_models.ResourceProvisioningState"]] = rest_field( - name="provisioningState", visibility=["read"] - ) - """The provisioning state of the resource. Known values are: \"Succeeded\", \"Failed\", and - \"Canceled\".""" - - @overload - def __init__( - self, - *, - target_type: str, - target_authentication_type: Union[str, "_models.TargetAuthenticationType"], - connection_server_name: str, - target_vault: Optional["_models.VaultSecret"] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class SqlDbElasticPoolTargetProperties(TargetProperties, discriminator="SqlEp"): - """The properties specific to elastic pool in Azure SQL Database. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - - :ivar target_authentication_type: The type of authentication to use when connecting to a - target. Required. Known values are: "Aad" and "Sql". - :vartype target_authentication_type: str or - ~azure.mgmt.databasewatcher.models.TargetAuthenticationType - :ivar target_vault: To use SQL authentication when connecting to targets, specify the vault - where the login name and password secrets are stored. - :vartype target_vault: ~azure.mgmt.databasewatcher.models.VaultSecret - :ivar connection_server_name: The server name to use in the connection string when connecting - to a target. Port number and instance name must be specified separately. Required. - :vartype connection_server_name: str - :ivar provisioning_state: The provisioning state of the resource. Known values are: - "Succeeded", "Failed", and "Canceled". - :vartype provisioning_state: str or - ~azure.mgmt.databasewatcher.models.ResourceProvisioningState - :ivar target_type: The Azure SQL DB elastic pool target. Required. Default value is "SqlEp". - :vartype target_type: str - :ivar sql_ep_resource_id: The Azure resource ID of an Azure SQL DB elastic pool target. - Required. - :vartype sql_ep_resource_id: str - :ivar anchor_database_resource_id: The Azure resource ID of the anchor database used to connect - to an elastic pool. Required. - :vartype anchor_database_resource_id: str - :ivar read_intent: Set to true to monitor a high availability replica of specified target, if - any. - :vartype read_intent: bool - """ - - target_type: Literal["SqlEp"] = rest_discriminator(name="targetType") # type: ignore - """The Azure SQL DB elastic pool target. Required. Default value is \"SqlEp\".""" - sql_ep_resource_id: str = rest_field(name="sqlEpResourceId") - """The Azure resource ID of an Azure SQL DB elastic pool target. Required.""" - anchor_database_resource_id: str = rest_field(name="anchorDatabaseResourceId") - """The Azure resource ID of the anchor database used to connect to an elastic pool. Required.""" - read_intent: Optional[bool] = rest_field(name="readIntent") - """Set to true to monitor a high availability replica of specified target, if any.""" - - @overload - def __init__( - self, - *, - target_authentication_type: Union[str, "_models.TargetAuthenticationType"], - connection_server_name: str, - sql_ep_resource_id: str, - anchor_database_resource_id: str, - target_vault: Optional["_models.VaultSecret"] = None, - read_intent: Optional[bool] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, target_type="SqlEp", **kwargs) - - -class SqlDbSingleDatabaseTargetProperties(TargetProperties, discriminator="SqlDb"): - """The properties specific to single database in Azure SQL Database. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - - :ivar target_authentication_type: The type of authentication to use when connecting to a - target. Required. Known values are: "Aad" and "Sql". - :vartype target_authentication_type: str or - ~azure.mgmt.databasewatcher.models.TargetAuthenticationType - :ivar target_vault: To use SQL authentication when connecting to targets, specify the vault - where the login name and password secrets are stored. - :vartype target_vault: ~azure.mgmt.databasewatcher.models.VaultSecret - :ivar connection_server_name: The server name to use in the connection string when connecting - to a target. Port number and instance name must be specified separately. Required. - :vartype connection_server_name: str - :ivar provisioning_state: The provisioning state of the resource. Known values are: - "Succeeded", "Failed", and "Canceled". - :vartype provisioning_state: str or - ~azure.mgmt.databasewatcher.models.ResourceProvisioningState - :ivar target_type: The Azure SQL DB single database target. Required. Default value is "SqlDb". - :vartype target_type: str - :ivar sql_db_resource_id: The Azure resource ID of an Azure SQL DB single database target. - Required. - :vartype sql_db_resource_id: str - :ivar read_intent: Set to true to monitor a high availability replica of specified target, if - any. - :vartype read_intent: bool - """ - - target_type: Literal["SqlDb"] = rest_discriminator(name="targetType") # type: ignore - """The Azure SQL DB single database target. Required. Default value is \"SqlDb\".""" - sql_db_resource_id: str = rest_field(name="sqlDbResourceId") - """The Azure resource ID of an Azure SQL DB single database target. Required.""" - read_intent: Optional[bool] = rest_field(name="readIntent") - """Set to true to monitor a high availability replica of specified target, if any.""" - - @overload - def __init__( - self, - *, - target_authentication_type: Union[str, "_models.TargetAuthenticationType"], - connection_server_name: str, - sql_db_resource_id: str, - target_vault: Optional["_models.VaultSecret"] = None, - read_intent: Optional[bool] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, target_type="SqlDb", **kwargs) - - -class SqlMiTargetProperties(TargetProperties, discriminator="SqlMi"): - """The properties specific to Azure SQL Managed Instance targets. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - - :ivar target_authentication_type: The type of authentication to use when connecting to a - target. Required. Known values are: "Aad" and "Sql". - :vartype target_authentication_type: str or - ~azure.mgmt.databasewatcher.models.TargetAuthenticationType - :ivar target_vault: To use SQL authentication when connecting to targets, specify the vault - where the login name and password secrets are stored. - :vartype target_vault: ~azure.mgmt.databasewatcher.models.VaultSecret - :ivar connection_server_name: The server name to use in the connection string when connecting - to a target. Port number and instance name must be specified separately. Required. - :vartype connection_server_name: str - :ivar provisioning_state: The provisioning state of the resource. Known values are: - "Succeeded", "Failed", and "Canceled". - :vartype provisioning_state: str or - ~azure.mgmt.databasewatcher.models.ResourceProvisioningState - :ivar target_type: The Azure SQL Managed Instance target. Required. Default value is "SqlMi". - :vartype target_type: str - :ivar sql_mi_resource_id: The Azure resource ID of an Azure SQL Managed Instance target. - Required. - :vartype sql_mi_resource_id: str - :ivar connection_tcp_port: The TCP port number to optionally use in the connection string when - connecting to an Azure SQL Managed Instance target. - :vartype connection_tcp_port: int - :ivar read_intent: Set to true to monitor a high availability replica of specified target, if - any. - :vartype read_intent: bool - """ - - target_type: Literal["SqlMi"] = rest_discriminator(name="targetType") # type: ignore - """The Azure SQL Managed Instance target. Required. Default value is \"SqlMi\".""" - sql_mi_resource_id: str = rest_field(name="sqlMiResourceId") - """The Azure resource ID of an Azure SQL Managed Instance target. Required.""" - connection_tcp_port: Optional[int] = rest_field(name="connectionTcpPort") - """The TCP port number to optionally use in the connection string when connecting to an Azure SQL - Managed Instance target.""" - read_intent: Optional[bool] = rest_field(name="readIntent") - """Set to true to monitor a high availability replica of specified target, if any.""" - - @overload - def __init__( - self, - *, - target_authentication_type: Union[str, "_models.TargetAuthenticationType"], - connection_server_name: str, - sql_mi_resource_id: str, - target_vault: Optional["_models.VaultSecret"] = None, - connection_tcp_port: Optional[int] = None, - read_intent: Optional[bool] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, target_type="SqlMi", **kwargs) - - -class SystemData(_model_base.Model): - """Metadata pertaining to creation and last modification of the resource. - - :ivar created_by: The identity that created the resource. - :vartype created_by: str - :ivar created_by_type: The type of identity that created the resource. Known values are: - "User", "Application", "ManagedIdentity", and "Key". - :vartype created_by_type: str or ~azure.mgmt.databasewatcher.models.CreatedByType - :ivar created_at: The timestamp of resource creation (UTC). - :vartype created_at: ~datetime.datetime - :ivar last_modified_by: The identity that last modified the resource. - :vartype last_modified_by: str - :ivar last_modified_by_type: The type of identity that last modified the resource. Known values - are: "User", "Application", "ManagedIdentity", and "Key". - :vartype last_modified_by_type: str or ~azure.mgmt.databasewatcher.models.CreatedByType - :ivar last_modified_at: The timestamp of resource last modification (UTC). - :vartype last_modified_at: ~datetime.datetime - """ - - created_by: Optional[str] = rest_field(name="createdBy") - """The identity that created the resource.""" - created_by_type: Optional[Union[str, "_models.CreatedByType"]] = rest_field(name="createdByType") - """The type of identity that created the resource. Known values are: \"User\", \"Application\", - \"ManagedIdentity\", and \"Key\".""" - created_at: Optional[datetime.datetime] = rest_field(name="createdAt", format="rfc3339") - """The timestamp of resource creation (UTC).""" - last_modified_by: Optional[str] = rest_field(name="lastModifiedBy") - """The identity that last modified the resource.""" - last_modified_by_type: Optional[Union[str, "_models.CreatedByType"]] = rest_field(name="lastModifiedByType") - """The type of identity that last modified the resource. Known values are: \"User\", - \"Application\", \"ManagedIdentity\", and \"Key\".""" - last_modified_at: Optional[datetime.datetime] = rest_field(name="lastModifiedAt", format="rfc3339") - """The timestamp of resource last modification (UTC).""" - - @overload - def __init__( - self, - *, - created_by: Optional[str] = None, - created_by_type: Optional[Union[str, "_models.CreatedByType"]] = None, - created_at: Optional[datetime.datetime] = None, - last_modified_by: Optional[str] = None, - last_modified_by_type: Optional[Union[str, "_models.CreatedByType"]] = None, - last_modified_at: Optional[datetime.datetime] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class Target(ProxyResource): - """Concrete proxy resource types can be created by aliasing this type using a specific property - type. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - :ivar id: Fully qualified resource ID for the resource. Ex - - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. # pylint: disable=line-too-long - :vartype id: str - :ivar name: The name of the resource. - :vartype name: str - :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or - "Microsoft.Storage/storageAccounts". - :vartype type: str - :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy - information. - :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData - :ivar properties: The resource-specific properties for this resource. - :vartype properties: ~azure.mgmt.databasewatcher.models.TargetProperties - """ - - properties: Optional["_models.TargetProperties"] = rest_field() - """The resource-specific properties for this resource.""" - - @overload - def __init__( - self, - *, - properties: Optional["_models.TargetProperties"] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class TrackedResource(Resource): - """The resource model definition for an Azure Resource Manager tracked top level resource which - has 'tags' and a 'location'. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - - :ivar id: Fully qualified resource ID for the resource. Ex - - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. # pylint: disable=line-too-long - :vartype id: str - :ivar name: The name of the resource. - :vartype name: str - :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or - "Microsoft.Storage/storageAccounts". - :vartype type: str - :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy - information. - :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar location: The geo-location where the resource lives. Required. - :vartype location: str - """ - - tags: Optional[Dict[str, str]] = rest_field() - """Resource tags.""" - location: str = rest_field(visibility=["read", "create"]) - """The geo-location where the resource lives. Required.""" - - @overload - def __init__( - self, - *, - location: str, - tags: Optional[Dict[str, str]] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class UserAssignedIdentity(_model_base.Model): - """User assigned identity properties. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - :ivar principal_id: The principal ID of the assigned identity. - :vartype principal_id: str - :ivar client_id: The client ID of the assigned identity. - :vartype client_id: str - """ - - principal_id: Optional[str] = rest_field(name="principalId", visibility=["read"]) - """The principal ID of the assigned identity.""" - client_id: Optional[str] = rest_field(name="clientId", visibility=["read"]) - """The client ID of the assigned identity.""" - - -class ValidationIssue(_model_base.Model): - """The model of a health validation issue. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - - :ivar error_code: The error code of the issue. Required. - :vartype error_code: str - :ivar error_message: The error message of the issue. Required. - :vartype error_message: str - :ivar additional_details: The additional details for the issue. - :vartype additional_details: str - :ivar recommendation_message: The recommendation for resolving the issue. Required. - :vartype recommendation_message: str - :ivar recommendation_url: The URL related to resolving the issue. - :vartype recommendation_url: str - :ivar related_resource_id: The resource ID of the Azure resource related to the issue. - :vartype related_resource_id: str - :ivar related_resource_type: The type of the Azure resource related to the issue. - :vartype related_resource_type: str - """ - - error_code: str = rest_field(name="errorCode", visibility=["read"]) - """The error code of the issue. Required.""" - error_message: str = rest_field(name="errorMessage", visibility=["read"]) - """The error message of the issue. Required.""" - additional_details: Optional[str] = rest_field(name="additionalDetails", visibility=["read"]) - """The additional details for the issue.""" - recommendation_message: str = rest_field(name="recommendationMessage", visibility=["read"]) - """The recommendation for resolving the issue. Required.""" - recommendation_url: Optional[str] = rest_field(name="recommendationUrl", visibility=["read"]) - """The URL related to resolving the issue.""" - related_resource_id: Optional[str] = rest_field(name="relatedResourceId", visibility=["read"]) - """The resource ID of the Azure resource related to the issue.""" - related_resource_type: Optional[str] = rest_field(name="relatedResourceType", visibility=["read"]) - """The type of the Azure resource related to the issue.""" - - -class VaultSecret(_model_base.Model): - """The vault specific details required if using SQL authentication to connect to a target. - - :ivar akv_resource_id: The Azure resource ID of the Key Vault instance storing database - authentication secrets. - :vartype akv_resource_id: str - :ivar akv_target_user: The path to the Key Vault secret storing the login name (aka user name, - aka account name) for authentication to a target. - :vartype akv_target_user: str - :ivar akv_target_password: The path to the Key Vault secret storing the password for - authentication to a target. - :vartype akv_target_password: str - """ - - akv_resource_id: Optional[str] = rest_field(name="akvResourceId") - """The Azure resource ID of the Key Vault instance storing database authentication secrets.""" - akv_target_user: Optional[str] = rest_field(name="akvTargetUser") - """The path to the Key Vault secret storing the login name (aka user name, aka account name) for - authentication to a target.""" - akv_target_password: Optional[str] = rest_field(name="akvTargetPassword") - """The path to the Key Vault secret storing the password for authentication to a target.""" - - @overload - def __init__( - self, - *, - akv_resource_id: Optional[str] = None, - akv_target_user: Optional[str] = None, - akv_target_password: Optional[str] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class Watcher(TrackedResource): - """The DatabaseWatcherProviderHub resource. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - - :ivar id: Fully qualified resource ID for the resource. Ex - - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. # pylint: disable=line-too-long - :vartype id: str - :ivar name: The name of the resource. - :vartype name: str - :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or - "Microsoft.Storage/storageAccounts". - :vartype type: str - :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy - information. - :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar location: The geo-location where the resource lives. Required. - :vartype location: str - :ivar properties: The resource-specific properties for this resource. - :vartype properties: ~azure.mgmt.databasewatcher.models.WatcherProperties - :ivar identity: The managed service identities assigned to this resource. - :vartype identity: ~azure.mgmt.databasewatcher.models.ManagedServiceIdentityV4 - """ - - properties: Optional["_models.WatcherProperties"] = rest_field() - """The resource-specific properties for this resource.""" - identity: Optional["_models.ManagedServiceIdentityV4"] = rest_field() - """The managed service identities assigned to this resource.""" - - @overload - def __init__( - self, - *, - location: str, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.WatcherProperties"] = None, - identity: Optional["_models.ManagedServiceIdentityV4"] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class WatcherProperties(_model_base.Model): - """The RP specific properties of the resource. - - Readonly variables are only populated by the server, and will be ignored when sending a request. - - :ivar datastore: The data store for collected monitoring data. - :vartype datastore: ~azure.mgmt.databasewatcher.models.Datastore - :ivar status: The monitoring collection status of the watcher. Known values are: "Starting", - "Running", "Stopping", "Stopped", and "Deleting". - :vartype status: str or ~azure.mgmt.databasewatcher.models.WatcherStatus - :ivar provisioning_state: The provisioning state of the resource watcher. Known values are: - "Succeeded", "Failed", and "Canceled". - :vartype provisioning_state: str or - ~azure.mgmt.databasewatcher.models.DatabaseWatcherProvisioningState - :ivar default_alert_rule_identity_resource_id: The resource ID of a user-assigned managed - identity that will be assigned to a new alert rule. - :vartype default_alert_rule_identity_resource_id: str - """ - - datastore: Optional["_models.Datastore"] = rest_field() - """The data store for collected monitoring data.""" - status: Optional[Union[str, "_models.WatcherStatus"]] = rest_field(visibility=["read"]) - """The monitoring collection status of the watcher. Known values are: \"Starting\", \"Running\", - \"Stopping\", \"Stopped\", and \"Deleting\".""" - provisioning_state: Optional[Union[str, "_models.DatabaseWatcherProvisioningState"]] = rest_field( - name="provisioningState", visibility=["read"] - ) - """The provisioning state of the resource watcher. Known values are: \"Succeeded\", \"Failed\", - and \"Canceled\".""" - default_alert_rule_identity_resource_id: Optional[str] = rest_field(name="defaultAlertRuleIdentityResourceId") - """The resource ID of a user-assigned managed identity that will be assigned to a new alert rule.""" - - @overload - def __init__( - self, - *, - datastore: Optional["_models.Datastore"] = None, - default_alert_rule_identity_resource_id: Optional[str] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class WatcherUpdate(_model_base.Model): - """The type used for update operations of the Watcher. - - :ivar identity: The managed service identities assigned to this resource. - :vartype identity: ~azure.mgmt.databasewatcher.models.ManagedServiceIdentityV4 - :ivar tags: Resource tags. - :vartype tags: dict[str, str] - :ivar properties: The resource-specific properties for this resource. - :vartype properties: ~azure.mgmt.databasewatcher.models.WatcherUpdateProperties - """ - - identity: Optional["_models.ManagedServiceIdentityV4"] = rest_field() - """The managed service identities assigned to this resource.""" - tags: Optional[Dict[str, str]] = rest_field() - """Resource tags.""" - properties: Optional["_models.WatcherUpdateProperties"] = rest_field() - """The resource-specific properties for this resource.""" - - @overload - def __init__( - self, - *, - identity: Optional["_models.ManagedServiceIdentityV4"] = None, - tags: Optional[Dict[str, str]] = None, - properties: Optional["_models.WatcherUpdateProperties"] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class WatcherUpdateProperties(_model_base.Model): - """The updatable properties of the Watcher. - - :ivar datastore: The data store for collected monitoring data. - :vartype datastore: ~azure.mgmt.databasewatcher.models.Datastore - :ivar default_alert_rule_identity_resource_id: The resource ID of a user-assigned managed - identity that will be assigned to a new alert rule. - :vartype default_alert_rule_identity_resource_id: str - """ - - datastore: Optional["_models.Datastore"] = rest_field() - """The data store for collected monitoring data.""" - default_alert_rule_identity_resource_id: Optional[str] = rest_field(name="defaultAlertRuleIdentityResourceId") - """The resource ID of a user-assigned managed identity that will be assigned to a new alert rule.""" - - @overload - def __init__( - self, - *, - datastore: Optional["_models.Datastore"] = None, - default_alert_rule_identity_resource_id: Optional[str] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/_models_py3.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/_models_py3.py new file mode 100644 index 000000000000..06e390c0ecbb --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/models/_models_py3.py @@ -0,0 +1,1808 @@ +# pylint: disable=line-too-long,useless-suppression,too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +import datetime +from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union + +from .._utils import serialization as _serialization + +if TYPE_CHECKING: + from .. import models as _models + + +class Resource(_serialization.Model): + """Common fields that are returned in the response for all Azure Resource Manager resources. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar id: Fully qualified resource ID for the resource. E.g. + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}". + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData + """ + + _validation = { + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "system_data": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "system_data": {"key": "systemData", "type": "SystemData"}, + } + + def __init__(self, **kwargs: Any) -> None: + """ """ + super().__init__(**kwargs) + self.id: Optional[str] = None + self.name: Optional[str] = None + self.type: Optional[str] = None + self.system_data: Optional["_models.SystemData"] = None + + +class ProxyResource(Resource): + """The resource model definition for a Azure Resource Manager proxy resource. It will not have + tags and a location. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar id: Fully qualified resource ID for the resource. E.g. + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}". + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData + """ + + +class AlertRuleResource(ProxyResource): + """Concrete proxy resource types can be created by aliasing this type using a specific property + type. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar id: Fully qualified resource ID for the resource. E.g. + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}". + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData + :ivar alert_rule_resource_id: The resource ID of the alert rule resource. + :vartype alert_rule_resource_id: str + :ivar created_with_properties: The properties with which the alert rule resource was created. + Known values are: "CreatedWithActionGroup" and "None". + :vartype created_with_properties: str or + ~azure.mgmt.databasewatcher.models.AlertRuleCreationProperties + :ivar creation_time: The creation time of the alert rule resource. + :vartype creation_time: ~datetime.datetime + :ivar provisioning_state: The provisioning state of the alert rule resource. Known values are: + "Succeeded", "Failed", and "Canceled". + :vartype provisioning_state: str or + ~azure.mgmt.databasewatcher.models.ResourceProvisioningState + :ivar alert_rule_template_id: The template ID associated with alert rule resource. + :vartype alert_rule_template_id: str + :ivar alert_rule_template_version: The alert rule template version. + :vartype alert_rule_template_version: str + """ + + _validation = { + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "system_data": {"readonly": True}, + "provisioning_state": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "system_data": {"key": "systemData", "type": "SystemData"}, + "alert_rule_resource_id": {"key": "properties.alertRuleResourceId", "type": "str"}, + "created_with_properties": {"key": "properties.createdWithProperties", "type": "str"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, + "alert_rule_template_id": {"key": "properties.alertRuleTemplateId", "type": "str"}, + "alert_rule_template_version": {"key": "properties.alertRuleTemplateVersion", "type": "str"}, + } + + def __init__( + self, + *, + alert_rule_resource_id: Optional[str] = None, + created_with_properties: Optional[Union[str, "_models.AlertRuleCreationProperties"]] = None, + creation_time: Optional[datetime.datetime] = None, + alert_rule_template_id: Optional[str] = None, + alert_rule_template_version: Optional[str] = None, + **kwargs: Any + ) -> None: + """ + :keyword alert_rule_resource_id: The resource ID of the alert rule resource. + :paramtype alert_rule_resource_id: str + :keyword created_with_properties: The properties with which the alert rule resource was + created. Known values are: "CreatedWithActionGroup" and "None". + :paramtype created_with_properties: str or + ~azure.mgmt.databasewatcher.models.AlertRuleCreationProperties + :keyword creation_time: The creation time of the alert rule resource. + :paramtype creation_time: ~datetime.datetime + :keyword alert_rule_template_id: The template ID associated with alert rule resource. + :paramtype alert_rule_template_id: str + :keyword alert_rule_template_version: The alert rule template version. + :paramtype alert_rule_template_version: str + """ + super().__init__(**kwargs) + self.alert_rule_resource_id = alert_rule_resource_id + self.created_with_properties = created_with_properties + self.creation_time = creation_time + self.provisioning_state: Optional[Union[str, "_models.ResourceProvisioningState"]] = None + self.alert_rule_template_id = alert_rule_template_id + self.alert_rule_template_version = alert_rule_template_version + + +class AlertRuleResourceListResult(_serialization.Model): + """The response of a AlertRuleResource list operation. + + All required parameters must be populated in order to send to server. + + :ivar value: The AlertRuleResource items on this page. Required. + :vartype value: list[~azure.mgmt.databasewatcher.models.AlertRuleResource] + :ivar next_link: The link to the next page of items. + :vartype next_link: str + """ + + _validation = { + "value": {"required": True}, + } + + _attribute_map = { + "value": {"key": "value", "type": "[AlertRuleResource]"}, + "next_link": {"key": "nextLink", "type": "str"}, + } + + def __init__( + self, *, value: List["_models.AlertRuleResource"], next_link: Optional[str] = None, **kwargs: Any + ) -> None: + """ + :keyword value: The AlertRuleResource items on this page. Required. + :paramtype value: list[~azure.mgmt.databasewatcher.models.AlertRuleResource] + :keyword next_link: The link to the next page of items. + :paramtype next_link: str + """ + super().__init__(**kwargs) + self.value = value + self.next_link = next_link + + +class Datastore(_serialization.Model): + """The properties of a data store. + + All required parameters must be populated in order to send to server. + + :ivar adx_cluster_resource_id: The Azure resource ID of an Azure Data Explorer cluster. + :vartype adx_cluster_resource_id: str + :ivar kusto_cluster_display_name: The Kusto cluster display name. + :vartype kusto_cluster_display_name: str + :ivar kusto_cluster_uri: The Kusto cluster URI. Required. + :vartype kusto_cluster_uri: str + :ivar kusto_data_ingestion_uri: The Kusto data ingestion URI. Required. + :vartype kusto_data_ingestion_uri: str + :ivar kusto_database_name: The name of a Kusto database. Required. + :vartype kusto_database_name: str + :ivar kusto_management_url: The Kusto management URL. Required. + :vartype kusto_management_url: str + :ivar kusto_offering_type: The type of a Kusto offering. Required. Known values are: "adx", + "free", and "fabric". + :vartype kusto_offering_type: str or ~azure.mgmt.databasewatcher.models.KustoOfferingType + """ + + _validation = { + "kusto_cluster_uri": {"required": True}, + "kusto_data_ingestion_uri": {"required": True}, + "kusto_database_name": {"required": True}, + "kusto_management_url": {"required": True}, + "kusto_offering_type": {"required": True}, + } + + _attribute_map = { + "adx_cluster_resource_id": {"key": "adxClusterResourceId", "type": "str"}, + "kusto_cluster_display_name": {"key": "kustoClusterDisplayName", "type": "str"}, + "kusto_cluster_uri": {"key": "kustoClusterUri", "type": "str"}, + "kusto_data_ingestion_uri": {"key": "kustoDataIngestionUri", "type": "str"}, + "kusto_database_name": {"key": "kustoDatabaseName", "type": "str"}, + "kusto_management_url": {"key": "kustoManagementUrl", "type": "str"}, + "kusto_offering_type": {"key": "kustoOfferingType", "type": "str"}, + } + + def __init__( + self, + *, + kusto_cluster_uri: str, + kusto_data_ingestion_uri: str, + kusto_database_name: str, + kusto_management_url: str, + kusto_offering_type: Union[str, "_models.KustoOfferingType"], + adx_cluster_resource_id: Optional[str] = None, + kusto_cluster_display_name: Optional[str] = None, + **kwargs: Any + ) -> None: + """ + :keyword adx_cluster_resource_id: The Azure resource ID of an Azure Data Explorer cluster. + :paramtype adx_cluster_resource_id: str + :keyword kusto_cluster_display_name: The Kusto cluster display name. + :paramtype kusto_cluster_display_name: str + :keyword kusto_cluster_uri: The Kusto cluster URI. Required. + :paramtype kusto_cluster_uri: str + :keyword kusto_data_ingestion_uri: The Kusto data ingestion URI. Required. + :paramtype kusto_data_ingestion_uri: str + :keyword kusto_database_name: The name of a Kusto database. Required. + :paramtype kusto_database_name: str + :keyword kusto_management_url: The Kusto management URL. Required. + :paramtype kusto_management_url: str + :keyword kusto_offering_type: The type of a Kusto offering. Required. Known values are: "adx", + "free", and "fabric". + :paramtype kusto_offering_type: str or ~azure.mgmt.databasewatcher.models.KustoOfferingType + """ + super().__init__(**kwargs) + self.adx_cluster_resource_id = adx_cluster_resource_id + self.kusto_cluster_display_name = kusto_cluster_display_name + self.kusto_cluster_uri = kusto_cluster_uri + self.kusto_data_ingestion_uri = kusto_data_ingestion_uri + self.kusto_database_name = kusto_database_name + self.kusto_management_url = kusto_management_url + self.kusto_offering_type = kusto_offering_type + + +class DatastoreUpdate(_serialization.Model): + """The properties of a data store. + + :ivar adx_cluster_resource_id: The Azure resource ID of an Azure Data Explorer cluster. + :vartype adx_cluster_resource_id: str + :ivar kusto_cluster_display_name: The Kusto cluster display name. + :vartype kusto_cluster_display_name: str + :ivar kusto_cluster_uri: The Kusto cluster URI. + :vartype kusto_cluster_uri: str + :ivar kusto_data_ingestion_uri: The Kusto data ingestion URI. + :vartype kusto_data_ingestion_uri: str + :ivar kusto_database_name: The name of a Kusto database. + :vartype kusto_database_name: str + :ivar kusto_management_url: The Kusto management URL. + :vartype kusto_management_url: str + :ivar kusto_offering_type: The type of a Kusto offering. Known values are: "adx", "free", and + "fabric". + :vartype kusto_offering_type: str or ~azure.mgmt.databasewatcher.models.KustoOfferingType + """ + + _attribute_map = { + "adx_cluster_resource_id": {"key": "adxClusterResourceId", "type": "str"}, + "kusto_cluster_display_name": {"key": "kustoClusterDisplayName", "type": "str"}, + "kusto_cluster_uri": {"key": "kustoClusterUri", "type": "str"}, + "kusto_data_ingestion_uri": {"key": "kustoDataIngestionUri", "type": "str"}, + "kusto_database_name": {"key": "kustoDatabaseName", "type": "str"}, + "kusto_management_url": {"key": "kustoManagementUrl", "type": "str"}, + "kusto_offering_type": {"key": "kustoOfferingType", "type": "str"}, + } + + def __init__( + self, + *, + adx_cluster_resource_id: Optional[str] = None, + kusto_cluster_display_name: Optional[str] = None, + kusto_cluster_uri: Optional[str] = None, + kusto_data_ingestion_uri: Optional[str] = None, + kusto_database_name: Optional[str] = None, + kusto_management_url: Optional[str] = None, + kusto_offering_type: Optional[Union[str, "_models.KustoOfferingType"]] = None, + **kwargs: Any + ) -> None: + """ + :keyword adx_cluster_resource_id: The Azure resource ID of an Azure Data Explorer cluster. + :paramtype adx_cluster_resource_id: str + :keyword kusto_cluster_display_name: The Kusto cluster display name. + :paramtype kusto_cluster_display_name: str + :keyword kusto_cluster_uri: The Kusto cluster URI. + :paramtype kusto_cluster_uri: str + :keyword kusto_data_ingestion_uri: The Kusto data ingestion URI. + :paramtype kusto_data_ingestion_uri: str + :keyword kusto_database_name: The name of a Kusto database. + :paramtype kusto_database_name: str + :keyword kusto_management_url: The Kusto management URL. + :paramtype kusto_management_url: str + :keyword kusto_offering_type: The type of a Kusto offering. Known values are: "adx", "free", + and "fabric". + :paramtype kusto_offering_type: str or ~azure.mgmt.databasewatcher.models.KustoOfferingType + """ + super().__init__(**kwargs) + self.adx_cluster_resource_id = adx_cluster_resource_id + self.kusto_cluster_display_name = kusto_cluster_display_name + self.kusto_cluster_uri = kusto_cluster_uri + self.kusto_data_ingestion_uri = kusto_data_ingestion_uri + self.kusto_database_name = kusto_database_name + self.kusto_management_url = kusto_management_url + self.kusto_offering_type = kusto_offering_type + + +class ErrorAdditionalInfo(_serialization.Model): + """The resource management error additional info. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar type: The additional info type. + :vartype type: str + :ivar info: The additional info. + :vartype info: JSON + """ + + _validation = { + "type": {"readonly": True}, + "info": {"readonly": True}, + } + + _attribute_map = { + "type": {"key": "type", "type": "str"}, + "info": {"key": "info", "type": "object"}, + } + + def __init__(self, **kwargs: Any) -> None: + """ """ + super().__init__(**kwargs) + self.type: Optional[str] = None + self.info: Optional[JSON] = None + + +class ErrorDetail(_serialization.Model): + """The error detail. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar code: The error code. + :vartype code: str + :ivar message: The error message. + :vartype message: str + :ivar target: The error target. + :vartype target: str + :ivar details: The error details. + :vartype details: list[~azure.mgmt.databasewatcher.models.ErrorDetail] + :ivar additional_info: The error additional info. + :vartype additional_info: list[~azure.mgmt.databasewatcher.models.ErrorAdditionalInfo] + """ + + _validation = { + "code": {"readonly": True}, + "message": {"readonly": True}, + "target": {"readonly": True}, + "details": {"readonly": True}, + "additional_info": {"readonly": True}, + } + + _attribute_map = { + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, + "target": {"key": "target", "type": "str"}, + "details": {"key": "details", "type": "[ErrorDetail]"}, + "additional_info": {"key": "additionalInfo", "type": "[ErrorAdditionalInfo]"}, + } + + def __init__(self, **kwargs: Any) -> None: + """ """ + super().__init__(**kwargs) + self.code: Optional[str] = None + self.message: Optional[str] = None + self.target: Optional[str] = None + self.details: Optional[List["_models.ErrorDetail"]] = None + self.additional_info: Optional[List["_models.ErrorAdditionalInfo"]] = None + + +class ErrorResponse(_serialization.Model): + """Common error response for all Azure Resource Manager APIs to return error details for failed + operations. (This also follows the OData error response format.). + + :ivar error: The error object. + :vartype error: ~azure.mgmt.databasewatcher.models.ErrorDetail + """ + + _attribute_map = { + "error": {"key": "error", "type": "ErrorDetail"}, + } + + def __init__(self, *, error: Optional["_models.ErrorDetail"] = None, **kwargs: Any) -> None: + """ + :keyword error: The error object. + :paramtype error: ~azure.mgmt.databasewatcher.models.ErrorDetail + """ + super().__init__(**kwargs) + self.error = error + + +class HealthValidation(ProxyResource): + """Concrete proxy resource types can be created by aliasing this type using a specific property + type. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar id: Fully qualified resource ID for the resource. E.g. + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}". + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData + :ivar start_time: The start time of health validation, in UTC. + :vartype start_time: ~datetime.datetime + :ivar end_time: The end time of health validation, in UTC. + :vartype end_time: ~datetime.datetime + :ivar status: The current health validation status. Known values are: "NotStarted", "Running", + "Succeeded", "Failed", "Canceled", and "TimedOut". + :vartype status: str or ~azure.mgmt.databasewatcher.models.ValidationStatus + :ivar issues: The list of issues found by health validation. + :vartype issues: list[~azure.mgmt.databasewatcher.models.ValidationIssue] + :ivar provisioning_state: The provisioning state of the health validation resource. Known + values are: "Succeeded", "Failed", and "Canceled". + :vartype provisioning_state: str or + ~azure.mgmt.databasewatcher.models.ResourceProvisioningState + """ + + _validation = { + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "system_data": {"readonly": True}, + "start_time": {"readonly": True}, + "end_time": {"readonly": True}, + "status": {"readonly": True}, + "issues": {"readonly": True}, + "provisioning_state": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "system_data": {"key": "systemData", "type": "SystemData"}, + "start_time": {"key": "properties.startTime", "type": "iso-8601"}, + "end_time": {"key": "properties.endTime", "type": "iso-8601"}, + "status": {"key": "properties.status", "type": "str"}, + "issues": {"key": "properties.issues", "type": "[ValidationIssue]"}, + "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, + } + + def __init__(self, **kwargs: Any) -> None: + """ """ + super().__init__(**kwargs) + self.start_time: Optional[datetime.datetime] = None + self.end_time: Optional[datetime.datetime] = None + self.status: Optional[Union[str, "_models.ValidationStatus"]] = None + self.issues: Optional[List["_models.ValidationIssue"]] = None + self.provisioning_state: Optional[Union[str, "_models.ResourceProvisioningState"]] = None + + +class HealthValidationListResult(_serialization.Model): + """The response of a HealthValidation list operation. + + All required parameters must be populated in order to send to server. + + :ivar value: The HealthValidation items on this page. Required. + :vartype value: list[~azure.mgmt.databasewatcher.models.HealthValidation] + :ivar next_link: The link to the next page of items. + :vartype next_link: str + """ + + _validation = { + "value": {"required": True}, + } + + _attribute_map = { + "value": {"key": "value", "type": "[HealthValidation]"}, + "next_link": {"key": "nextLink", "type": "str"}, + } + + def __init__( + self, *, value: List["_models.HealthValidation"], next_link: Optional[str] = None, **kwargs: Any + ) -> None: + """ + :keyword value: The HealthValidation items on this page. Required. + :paramtype value: list[~azure.mgmt.databasewatcher.models.HealthValidation] + :keyword next_link: The link to the next page of items. + :paramtype next_link: str + """ + super().__init__(**kwargs) + self.value = value + self.next_link = next_link + + +class ManagedServiceIdentity(_serialization.Model): + """Managed service identity (system assigned and/or user assigned identities). + + Variables are only populated by the server, and will be ignored when sending a request. + + All required parameters must be populated in order to send to server. + + :ivar principal_id: The service principal ID of the system assigned identity. This property + will only be provided for a system assigned identity. + :vartype principal_id: str + :ivar tenant_id: The tenant ID of the system assigned identity. This property will only be + provided for a system assigned identity. + :vartype tenant_id: str + :ivar type: Type of managed service identity (where both SystemAssigned and UserAssigned types + are allowed). Required. Known values are: "None", "SystemAssigned", "UserAssigned", and + "SystemAssigned, UserAssigned". + :vartype type: str or ~azure.mgmt.databasewatcher.models.ManagedServiceIdentityType + :ivar user_assigned_identities: The set of user assigned identities associated with the + resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: + '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. + The dictionary values can be empty objects ({}) in requests. + :vartype user_assigned_identities: dict[str, + ~azure.mgmt.databasewatcher.models.UserAssignedIdentity] + """ + + _validation = { + "principal_id": {"readonly": True}, + "tenant_id": {"readonly": True}, + "type": {"required": True}, + } + + _attribute_map = { + "principal_id": {"key": "principalId", "type": "str"}, + "tenant_id": {"key": "tenantId", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "user_assigned_identities": {"key": "userAssignedIdentities", "type": "{UserAssignedIdentity}"}, + } + + def __init__( + self, + *, + type: Union[str, "_models.ManagedServiceIdentityType"], + user_assigned_identities: Optional[Dict[str, "_models.UserAssignedIdentity"]] = None, + **kwargs: Any + ) -> None: + """ + :keyword type: Type of managed service identity (where both SystemAssigned and UserAssigned + types are allowed). Required. Known values are: "None", "SystemAssigned", "UserAssigned", and + "SystemAssigned, UserAssigned". + :paramtype type: str or ~azure.mgmt.databasewatcher.models.ManagedServiceIdentityType + :keyword user_assigned_identities: The set of user assigned identities associated with the + resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: + '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. + The dictionary values can be empty objects ({}) in requests. + :paramtype user_assigned_identities: dict[str, + ~azure.mgmt.databasewatcher.models.UserAssignedIdentity] + """ + super().__init__(**kwargs) + self.principal_id: Optional[str] = None + self.tenant_id: Optional[str] = None + self.type = type + self.user_assigned_identities = user_assigned_identities + + +class Operation(_serialization.Model): + """Details of a REST API operation, returned from the Resource Provider Operations API. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar name: The name of the operation, as per Resource-Based Access Control (RBAC). Examples: + "Microsoft.Compute/virtualMachines/write", "Microsoft.Compute/virtualMachines/capture/action". + :vartype name: str + :ivar is_data_action: Whether the operation applies to data-plane. This is "true" for + data-plane operations and "false" for ARM/control-plane operations. + :vartype is_data_action: bool + :ivar display: Localized display information for this particular operation. + :vartype display: ~azure.mgmt.databasewatcher.models.OperationDisplay + :ivar origin: The intended executor of the operation; as in Resource Based Access Control + (RBAC) and audit logs UX. Default value is "user,system". Known values are: "user", "system", + and "user,system". + :vartype origin: str or ~azure.mgmt.databasewatcher.models.Origin + :ivar action_type: Enum. Indicates the action type. "Internal" refers to actions that are for + internal only APIs. "Internal" + :vartype action_type: str or ~azure.mgmt.databasewatcher.models.ActionType + """ + + _validation = { + "name": {"readonly": True}, + "is_data_action": {"readonly": True}, + "origin": {"readonly": True}, + "action_type": {"readonly": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "is_data_action": {"key": "isDataAction", "type": "bool"}, + "display": {"key": "display", "type": "OperationDisplay"}, + "origin": {"key": "origin", "type": "str"}, + "action_type": {"key": "actionType", "type": "str"}, + } + + def __init__(self, *, display: Optional["_models.OperationDisplay"] = None, **kwargs: Any) -> None: + """ + :keyword display: Localized display information for this particular operation. + :paramtype display: ~azure.mgmt.databasewatcher.models.OperationDisplay + """ + super().__init__(**kwargs) + self.name: Optional[str] = None + self.is_data_action: Optional[bool] = None + self.display = display + self.origin: Optional[Union[str, "_models.Origin"]] = None + self.action_type: Optional[Union[str, "_models.ActionType"]] = None + + +class OperationDisplay(_serialization.Model): + """Localized display information for this particular operation. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar provider: The localized friendly form of the resource provider name, e.g. "Microsoft + Monitoring Insights" or "Microsoft Compute". + :vartype provider: str + :ivar resource: The localized friendly name of the resource type related to this operation. + E.g. "Virtual Machines" or "Job Schedule Collections". + :vartype resource: str + :ivar operation: The concise, localized friendly name for the operation; suitable for + dropdowns. E.g. "Create or Update Virtual Machine", "Restart Virtual Machine". + :vartype operation: str + :ivar description: The short, localized friendly description of the operation; suitable for + tool tips and detailed views. + :vartype description: str + """ + + _validation = { + "provider": {"readonly": True}, + "resource": {"readonly": True}, + "operation": {"readonly": True}, + "description": {"readonly": True}, + } + + _attribute_map = { + "provider": {"key": "provider", "type": "str"}, + "resource": {"key": "resource", "type": "str"}, + "operation": {"key": "operation", "type": "str"}, + "description": {"key": "description", "type": "str"}, + } + + def __init__(self, **kwargs: Any) -> None: + """ """ + super().__init__(**kwargs) + self.provider: Optional[str] = None + self.resource: Optional[str] = None + self.operation: Optional[str] = None + self.description: Optional[str] = None + + +class OperationListResult(_serialization.Model): + """A list of REST API operations supported by an Azure Resource Provider. It contains an URL link + to get the next set of results. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar value: List of operations supported by the resource provider. + :vartype value: list[~azure.mgmt.databasewatcher.models.Operation] + :ivar next_link: URL to get the next set of operation list results (if there are any). + :vartype next_link: str + """ + + _validation = { + "value": {"readonly": True}, + "next_link": {"readonly": True}, + } + + _attribute_map = { + "value": {"key": "value", "type": "[Operation]"}, + "next_link": {"key": "nextLink", "type": "str"}, + } + + def __init__(self, **kwargs: Any) -> None: + """ """ + super().__init__(**kwargs) + self.value: Optional[List["_models.Operation"]] = None + self.next_link: Optional[str] = None + + +class SharedPrivateLinkResource(ProxyResource): + """Concrete proxy resource types can be created by aliasing this type using a specific property + type. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar id: Fully qualified resource ID for the resource. E.g. + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}". + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData + :ivar private_link_resource_id: The resource ID of the resource the shared private link + resource is for. + :vartype private_link_resource_id: str + :ivar group_id: The group id from the provider of resource the shared private link resource is + for. + :vartype group_id: str + :ivar request_message: The request message for requesting approval of the shared private link + resource. + :vartype request_message: str + :ivar dns_zone: The DNS zone segment to be included in the DNS name of the shared private link. + Value is required for Azure Data Explorer clusters and SQL managed instances, and must be + omitted for SQL logical servers and key vaults. The value is the second segment of the host + FQDN name of the resource that the shared private link resource is for. For example: if the + host name is 'adx-cluster-21187695.eastus.kusto.windows.net', then the value is 'eastus'; if + the host name is 'sql-mi-23961134.767d5869f605.database.windows.net', then the value is + '767d5869f605'. + :vartype dns_zone: str + :ivar status: Status of the shared private link resource. Can be Pending, Approved, Rejected or + Disconnected. Known values are: "Pending", "Approved", "Rejected", and "Disconnected". + :vartype status: str or ~azure.mgmt.databasewatcher.models.SharedPrivateLinkResourceStatus + :ivar provisioning_state: The provisioning state of the resource. Known values are: + "Succeeded", "Failed", and "Canceled". + :vartype provisioning_state: str or + ~azure.mgmt.databasewatcher.models.ResourceProvisioningState + """ + + _validation = { + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "system_data": {"readonly": True}, + "status": {"readonly": True}, + "provisioning_state": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "system_data": {"key": "systemData", "type": "SystemData"}, + "private_link_resource_id": {"key": "properties.privateLinkResourceId", "type": "str"}, + "group_id": {"key": "properties.groupId", "type": "str"}, + "request_message": {"key": "properties.requestMessage", "type": "str"}, + "dns_zone": {"key": "properties.dnsZone", "type": "str"}, + "status": {"key": "properties.status", "type": "str"}, + "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, + } + + def __init__( + self, + *, + private_link_resource_id: Optional[str] = None, + group_id: Optional[str] = None, + request_message: Optional[str] = None, + dns_zone: Optional[str] = None, + **kwargs: Any + ) -> None: + """ + :keyword private_link_resource_id: The resource ID of the resource the shared private link + resource is for. + :paramtype private_link_resource_id: str + :keyword group_id: The group id from the provider of resource the shared private link resource + is for. + :paramtype group_id: str + :keyword request_message: The request message for requesting approval of the shared private + link resource. + :paramtype request_message: str + :keyword dns_zone: The DNS zone segment to be included in the DNS name of the shared private + link. Value is required for Azure Data Explorer clusters and SQL managed instances, and must be + omitted for SQL logical servers and key vaults. The value is the second segment of the host + FQDN name of the resource that the shared private link resource is for. For example: if the + host name is 'adx-cluster-21187695.eastus.kusto.windows.net', then the value is 'eastus'; if + the host name is 'sql-mi-23961134.767d5869f605.database.windows.net', then the value is + '767d5869f605'. + :paramtype dns_zone: str + """ + super().__init__(**kwargs) + self.private_link_resource_id = private_link_resource_id + self.group_id = group_id + self.request_message = request_message + self.dns_zone = dns_zone + self.status: Optional[Union[str, "_models.SharedPrivateLinkResourceStatus"]] = None + self.provisioning_state: Optional[Union[str, "_models.ResourceProvisioningState"]] = None + + +class SharedPrivateLinkResourceListResult(_serialization.Model): + """The response of a SharedPrivateLinkResource list operation. + + All required parameters must be populated in order to send to server. + + :ivar value: The SharedPrivateLinkResource items on this page. Required. + :vartype value: list[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] + :ivar next_link: The link to the next page of items. + :vartype next_link: str + """ + + _validation = { + "value": {"required": True}, + } + + _attribute_map = { + "value": {"key": "value", "type": "[SharedPrivateLinkResource]"}, + "next_link": {"key": "nextLink", "type": "str"}, + } + + def __init__( + self, *, value: List["_models.SharedPrivateLinkResource"], next_link: Optional[str] = None, **kwargs: Any + ) -> None: + """ + :keyword value: The SharedPrivateLinkResource items on this page. Required. + :paramtype value: list[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] + :keyword next_link: The link to the next page of items. + :paramtype next_link: str + """ + super().__init__(**kwargs) + self.value = value + self.next_link = next_link + + +class TargetProperties(_serialization.Model): + """The generic properties of a target. + + You probably want to use the sub-classes and not this class directly. Known sub-classes are: + SqlDbSingleDatabaseTargetProperties, SqlDbElasticPoolTargetProperties, SqlMiTargetProperties + + Variables are only populated by the server, and will be ignored when sending a request. + + All required parameters must be populated in order to send to server. + + :ivar target_type: Discriminator property for TargetProperties. Required. + :vartype target_type: str + :ivar target_authentication_type: The type of authentication to use when connecting to a + target. Required. Known values are: "Aad" and "Sql". + :vartype target_authentication_type: str or + ~azure.mgmt.databasewatcher.models.TargetAuthenticationType + :ivar target_vault: To use SQL authentication when connecting to targets, specify the vault + where the login name and password secrets are stored. + :vartype target_vault: ~azure.mgmt.databasewatcher.models.VaultSecret + :ivar connection_server_name: The FQDN host name of the server to use in the connection string + when connecting to a target. For example, for an Azure SQL logical server in the Azure + commercial cloud, the value might be 'sql-logical-server-22092780.database.windows.net'; for an + Azure SQL managed instance in the Azure commercial cloud, the value might be + 'sql-mi-39441134.767d5869f605.database.windows.net'. Port number and instance name must be + specified separately. Required. + :vartype connection_server_name: str + :ivar provisioning_state: The provisioning state of the resource. Known values are: + "Succeeded", "Failed", and "Canceled". + :vartype provisioning_state: str or + ~azure.mgmt.databasewatcher.models.ResourceProvisioningState + """ + + _validation = { + "target_type": {"required": True}, + "target_authentication_type": {"required": True}, + "connection_server_name": {"required": True, "max_length": 200}, + "provisioning_state": {"readonly": True}, + } + + _attribute_map = { + "target_type": {"key": "targetType", "type": "str"}, + "target_authentication_type": {"key": "targetAuthenticationType", "type": "str"}, + "target_vault": {"key": "targetVault", "type": "VaultSecret"}, + "connection_server_name": {"key": "connectionServerName", "type": "str"}, + "provisioning_state": {"key": "provisioningState", "type": "str"}, + } + + _subtype_map = { + "target_type": { + "SqlDb": "SqlDbSingleDatabaseTargetProperties", + "SqlEp": "SqlDbElasticPoolTargetProperties", + "SqlMi": "SqlMiTargetProperties", + } + } + + def __init__( + self, + *, + target_authentication_type: Union[str, "_models.TargetAuthenticationType"], + connection_server_name: str, + target_vault: Optional["_models.VaultSecret"] = None, + **kwargs: Any + ) -> None: + """ + :keyword target_authentication_type: The type of authentication to use when connecting to a + target. Required. Known values are: "Aad" and "Sql". + :paramtype target_authentication_type: str or + ~azure.mgmt.databasewatcher.models.TargetAuthenticationType + :keyword target_vault: To use SQL authentication when connecting to targets, specify the vault + where the login name and password secrets are stored. + :paramtype target_vault: ~azure.mgmt.databasewatcher.models.VaultSecret + :keyword connection_server_name: The FQDN host name of the server to use in the connection + string when connecting to a target. For example, for an Azure SQL logical server in the Azure + commercial cloud, the value might be 'sql-logical-server-22092780.database.windows.net'; for an + Azure SQL managed instance in the Azure commercial cloud, the value might be + 'sql-mi-39441134.767d5869f605.database.windows.net'. Port number and instance name must be + specified separately. Required. + :paramtype connection_server_name: str + """ + super().__init__(**kwargs) + self.target_type: Optional[str] = None + self.target_authentication_type = target_authentication_type + self.target_vault = target_vault + self.connection_server_name = connection_server_name + self.provisioning_state: Optional[Union[str, "_models.ResourceProvisioningState"]] = None + + +class SqlDbElasticPoolTargetProperties(TargetProperties): + """The properties specific to an elastic pool in Azure SQL Database. + + Variables are only populated by the server, and will be ignored when sending a request. + + All required parameters must be populated in order to send to server. + + :ivar target_type: Discriminator property for TargetProperties. Required. + :vartype target_type: str + :ivar target_authentication_type: The type of authentication to use when connecting to a + target. Required. Known values are: "Aad" and "Sql". + :vartype target_authentication_type: str or + ~azure.mgmt.databasewatcher.models.TargetAuthenticationType + :ivar target_vault: To use SQL authentication when connecting to targets, specify the vault + where the login name and password secrets are stored. + :vartype target_vault: ~azure.mgmt.databasewatcher.models.VaultSecret + :ivar connection_server_name: The FQDN host name of the server to use in the connection string + when connecting to a target. For example, for an Azure SQL logical server in the Azure + commercial cloud, the value might be 'sql-logical-server-22092780.database.windows.net'; for an + Azure SQL managed instance in the Azure commercial cloud, the value might be + 'sql-mi-39441134.767d5869f605.database.windows.net'. Port number and instance name must be + specified separately. Required. + :vartype connection_server_name: str + :ivar provisioning_state: The provisioning state of the resource. Known values are: + "Succeeded", "Failed", and "Canceled". + :vartype provisioning_state: str or + ~azure.mgmt.databasewatcher.models.ResourceProvisioningState + :ivar sql_ep_resource_id: The Azure resource ID of an Azure SQL DB elastic pool target. + Required. + :vartype sql_ep_resource_id: str + :ivar anchor_database_resource_id: The Azure resource ID of the anchor database used to connect + to an elastic pool. Required. + :vartype anchor_database_resource_id: str + :ivar read_intent: Set to true to monitor a high availability replica of specified target, if + any. + :vartype read_intent: bool + """ + + _validation = { + "target_type": {"required": True}, + "target_authentication_type": {"required": True}, + "connection_server_name": {"required": True, "max_length": 200}, + "provisioning_state": {"readonly": True}, + "sql_ep_resource_id": {"required": True}, + "anchor_database_resource_id": {"required": True}, + } + + _attribute_map = { + "target_type": {"key": "targetType", "type": "str"}, + "target_authentication_type": {"key": "targetAuthenticationType", "type": "str"}, + "target_vault": {"key": "targetVault", "type": "VaultSecret"}, + "connection_server_name": {"key": "connectionServerName", "type": "str"}, + "provisioning_state": {"key": "provisioningState", "type": "str"}, + "sql_ep_resource_id": {"key": "sqlEpResourceId", "type": "str"}, + "anchor_database_resource_id": {"key": "anchorDatabaseResourceId", "type": "str"}, + "read_intent": {"key": "readIntent", "type": "bool"}, + } + + def __init__( + self, + *, + target_authentication_type: Union[str, "_models.TargetAuthenticationType"], + connection_server_name: str, + sql_ep_resource_id: str, + anchor_database_resource_id: str, + target_vault: Optional["_models.VaultSecret"] = None, + read_intent: bool = False, + **kwargs: Any + ) -> None: + """ + :keyword target_authentication_type: The type of authentication to use when connecting to a + target. Required. Known values are: "Aad" and "Sql". + :paramtype target_authentication_type: str or + ~azure.mgmt.databasewatcher.models.TargetAuthenticationType + :keyword target_vault: To use SQL authentication when connecting to targets, specify the vault + where the login name and password secrets are stored. + :paramtype target_vault: ~azure.mgmt.databasewatcher.models.VaultSecret + :keyword connection_server_name: The FQDN host name of the server to use in the connection + string when connecting to a target. For example, for an Azure SQL logical server in the Azure + commercial cloud, the value might be 'sql-logical-server-22092780.database.windows.net'; for an + Azure SQL managed instance in the Azure commercial cloud, the value might be + 'sql-mi-39441134.767d5869f605.database.windows.net'. Port number and instance name must be + specified separately. Required. + :paramtype connection_server_name: str + :keyword sql_ep_resource_id: The Azure resource ID of an Azure SQL DB elastic pool target. + Required. + :paramtype sql_ep_resource_id: str + :keyword anchor_database_resource_id: The Azure resource ID of the anchor database used to + connect to an elastic pool. Required. + :paramtype anchor_database_resource_id: str + :keyword read_intent: Set to true to monitor a high availability replica of specified target, + if any. + :paramtype read_intent: bool + """ + super().__init__( + target_authentication_type=target_authentication_type, + target_vault=target_vault, + connection_server_name=connection_server_name, + **kwargs + ) + self.target_type: str = "SqlEp" + self.sql_ep_resource_id = sql_ep_resource_id + self.anchor_database_resource_id = anchor_database_resource_id + self.read_intent = read_intent + + +class SqlDbSingleDatabaseTargetProperties(TargetProperties): + """The properties specific to a database in Azure SQL Database. + + Variables are only populated by the server, and will be ignored when sending a request. + + All required parameters must be populated in order to send to server. + + :ivar target_type: Discriminator property for TargetProperties. Required. + :vartype target_type: str + :ivar target_authentication_type: The type of authentication to use when connecting to a + target. Required. Known values are: "Aad" and "Sql". + :vartype target_authentication_type: str or + ~azure.mgmt.databasewatcher.models.TargetAuthenticationType + :ivar target_vault: To use SQL authentication when connecting to targets, specify the vault + where the login name and password secrets are stored. + :vartype target_vault: ~azure.mgmt.databasewatcher.models.VaultSecret + :ivar connection_server_name: The FQDN host name of the server to use in the connection string + when connecting to a target. For example, for an Azure SQL logical server in the Azure + commercial cloud, the value might be 'sql-logical-server-22092780.database.windows.net'; for an + Azure SQL managed instance in the Azure commercial cloud, the value might be + 'sql-mi-39441134.767d5869f605.database.windows.net'. Port number and instance name must be + specified separately. Required. + :vartype connection_server_name: str + :ivar provisioning_state: The provisioning state of the resource. Known values are: + "Succeeded", "Failed", and "Canceled". + :vartype provisioning_state: str or + ~azure.mgmt.databasewatcher.models.ResourceProvisioningState + :ivar sql_db_resource_id: The Azure resource ID of an Azure SQL DB database target. Required. + :vartype sql_db_resource_id: str + :ivar read_intent: Set to true to monitor a high availability replica of specified target, if + any. + :vartype read_intent: bool + """ + + _validation = { + "target_type": {"required": True}, + "target_authentication_type": {"required": True}, + "connection_server_name": {"required": True, "max_length": 200}, + "provisioning_state": {"readonly": True}, + "sql_db_resource_id": {"required": True}, + } + + _attribute_map = { + "target_type": {"key": "targetType", "type": "str"}, + "target_authentication_type": {"key": "targetAuthenticationType", "type": "str"}, + "target_vault": {"key": "targetVault", "type": "VaultSecret"}, + "connection_server_name": {"key": "connectionServerName", "type": "str"}, + "provisioning_state": {"key": "provisioningState", "type": "str"}, + "sql_db_resource_id": {"key": "sqlDbResourceId", "type": "str"}, + "read_intent": {"key": "readIntent", "type": "bool"}, + } + + def __init__( + self, + *, + target_authentication_type: Union[str, "_models.TargetAuthenticationType"], + connection_server_name: str, + sql_db_resource_id: str, + target_vault: Optional["_models.VaultSecret"] = None, + read_intent: bool = False, + **kwargs: Any + ) -> None: + """ + :keyword target_authentication_type: The type of authentication to use when connecting to a + target. Required. Known values are: "Aad" and "Sql". + :paramtype target_authentication_type: str or + ~azure.mgmt.databasewatcher.models.TargetAuthenticationType + :keyword target_vault: To use SQL authentication when connecting to targets, specify the vault + where the login name and password secrets are stored. + :paramtype target_vault: ~azure.mgmt.databasewatcher.models.VaultSecret + :keyword connection_server_name: The FQDN host name of the server to use in the connection + string when connecting to a target. For example, for an Azure SQL logical server in the Azure + commercial cloud, the value might be 'sql-logical-server-22092780.database.windows.net'; for an + Azure SQL managed instance in the Azure commercial cloud, the value might be + 'sql-mi-39441134.767d5869f605.database.windows.net'. Port number and instance name must be + specified separately. Required. + :paramtype connection_server_name: str + :keyword sql_db_resource_id: The Azure resource ID of an Azure SQL DB database target. + Required. + :paramtype sql_db_resource_id: str + :keyword read_intent: Set to true to monitor a high availability replica of specified target, + if any. + :paramtype read_intent: bool + """ + super().__init__( + target_authentication_type=target_authentication_type, + target_vault=target_vault, + connection_server_name=connection_server_name, + **kwargs + ) + self.target_type: str = "SqlDb" + self.sql_db_resource_id = sql_db_resource_id + self.read_intent = read_intent + + +class SqlMiTargetProperties(TargetProperties): + """The properties specific to Azure SQL Managed Instance targets. + + Variables are only populated by the server, and will be ignored when sending a request. + + All required parameters must be populated in order to send to server. + + :ivar target_type: Discriminator property for TargetProperties. Required. + :vartype target_type: str + :ivar target_authentication_type: The type of authentication to use when connecting to a + target. Required. Known values are: "Aad" and "Sql". + :vartype target_authentication_type: str or + ~azure.mgmt.databasewatcher.models.TargetAuthenticationType + :ivar target_vault: To use SQL authentication when connecting to targets, specify the vault + where the login name and password secrets are stored. + :vartype target_vault: ~azure.mgmt.databasewatcher.models.VaultSecret + :ivar connection_server_name: The FQDN host name of the server to use in the connection string + when connecting to a target. For example, for an Azure SQL logical server in the Azure + commercial cloud, the value might be 'sql-logical-server-22092780.database.windows.net'; for an + Azure SQL managed instance in the Azure commercial cloud, the value might be + 'sql-mi-39441134.767d5869f605.database.windows.net'. Port number and instance name must be + specified separately. Required. + :vartype connection_server_name: str + :ivar provisioning_state: The provisioning state of the resource. Known values are: + "Succeeded", "Failed", and "Canceled". + :vartype provisioning_state: str or + ~azure.mgmt.databasewatcher.models.ResourceProvisioningState + :ivar sql_mi_resource_id: The Azure resource ID of an Azure SQL Managed Instance target. + Required. + :vartype sql_mi_resource_id: str + :ivar connection_tcp_port: The TCP port number to optionally use in the connection string when + connecting to an Azure SQL Managed Instance target. + :vartype connection_tcp_port: int + :ivar read_intent: Set to true to monitor a high availability replica of specified target, if + any. + :vartype read_intent: bool + """ + + _validation = { + "target_type": {"required": True}, + "target_authentication_type": {"required": True}, + "connection_server_name": {"required": True, "max_length": 200}, + "provisioning_state": {"readonly": True}, + "sql_mi_resource_id": {"required": True}, + } + + _attribute_map = { + "target_type": {"key": "targetType", "type": "str"}, + "target_authentication_type": {"key": "targetAuthenticationType", "type": "str"}, + "target_vault": {"key": "targetVault", "type": "VaultSecret"}, + "connection_server_name": {"key": "connectionServerName", "type": "str"}, + "provisioning_state": {"key": "provisioningState", "type": "str"}, + "sql_mi_resource_id": {"key": "sqlMiResourceId", "type": "str"}, + "connection_tcp_port": {"key": "connectionTcpPort", "type": "int"}, + "read_intent": {"key": "readIntent", "type": "bool"}, + } + + def __init__( + self, + *, + target_authentication_type: Union[str, "_models.TargetAuthenticationType"], + connection_server_name: str, + sql_mi_resource_id: str, + target_vault: Optional["_models.VaultSecret"] = None, + connection_tcp_port: int = 1433, + read_intent: bool = False, + **kwargs: Any + ) -> None: + """ + :keyword target_authentication_type: The type of authentication to use when connecting to a + target. Required. Known values are: "Aad" and "Sql". + :paramtype target_authentication_type: str or + ~azure.mgmt.databasewatcher.models.TargetAuthenticationType + :keyword target_vault: To use SQL authentication when connecting to targets, specify the vault + where the login name and password secrets are stored. + :paramtype target_vault: ~azure.mgmt.databasewatcher.models.VaultSecret + :keyword connection_server_name: The FQDN host name of the server to use in the connection + string when connecting to a target. For example, for an Azure SQL logical server in the Azure + commercial cloud, the value might be 'sql-logical-server-22092780.database.windows.net'; for an + Azure SQL managed instance in the Azure commercial cloud, the value might be + 'sql-mi-39441134.767d5869f605.database.windows.net'. Port number and instance name must be + specified separately. Required. + :paramtype connection_server_name: str + :keyword sql_mi_resource_id: The Azure resource ID of an Azure SQL Managed Instance target. + Required. + :paramtype sql_mi_resource_id: str + :keyword connection_tcp_port: The TCP port number to optionally use in the connection string + when connecting to an Azure SQL Managed Instance target. + :paramtype connection_tcp_port: int + :keyword read_intent: Set to true to monitor a high availability replica of specified target, + if any. + :paramtype read_intent: bool + """ + super().__init__( + target_authentication_type=target_authentication_type, + target_vault=target_vault, + connection_server_name=connection_server_name, + **kwargs + ) + self.target_type: str = "SqlMi" + self.sql_mi_resource_id = sql_mi_resource_id + self.connection_tcp_port = connection_tcp_port + self.read_intent = read_intent + + +class SystemData(_serialization.Model): + """Metadata pertaining to creation and last modification of the resource. + + :ivar created_by: The identity that created the resource. + :vartype created_by: str + :ivar created_by_type: The type of identity that created the resource. Known values are: + "User", "Application", "ManagedIdentity", and "Key". + :vartype created_by_type: str or ~azure.mgmt.databasewatcher.models.CreatedByType + :ivar created_at: The timestamp of resource creation (UTC). + :vartype created_at: ~datetime.datetime + :ivar last_modified_by: The identity that last modified the resource. + :vartype last_modified_by: str + :ivar last_modified_by_type: The type of identity that last modified the resource. Known values + are: "User", "Application", "ManagedIdentity", and "Key". + :vartype last_modified_by_type: str or ~azure.mgmt.databasewatcher.models.CreatedByType + :ivar last_modified_at: The timestamp of resource last modification (UTC). + :vartype last_modified_at: ~datetime.datetime + """ + + _attribute_map = { + "created_by": {"key": "createdBy", "type": "str"}, + "created_by_type": {"key": "createdByType", "type": "str"}, + "created_at": {"key": "createdAt", "type": "iso-8601"}, + "last_modified_by": {"key": "lastModifiedBy", "type": "str"}, + "last_modified_by_type": {"key": "lastModifiedByType", "type": "str"}, + "last_modified_at": {"key": "lastModifiedAt", "type": "iso-8601"}, + } + + def __init__( + self, + *, + created_by: Optional[str] = None, + created_by_type: Optional[Union[str, "_models.CreatedByType"]] = None, + created_at: Optional[datetime.datetime] = None, + last_modified_by: Optional[str] = None, + last_modified_by_type: Optional[Union[str, "_models.CreatedByType"]] = None, + last_modified_at: Optional[datetime.datetime] = None, + **kwargs: Any + ) -> None: + """ + :keyword created_by: The identity that created the resource. + :paramtype created_by: str + :keyword created_by_type: The type of identity that created the resource. Known values are: + "User", "Application", "ManagedIdentity", and "Key". + :paramtype created_by_type: str or ~azure.mgmt.databasewatcher.models.CreatedByType + :keyword created_at: The timestamp of resource creation (UTC). + :paramtype created_at: ~datetime.datetime + :keyword last_modified_by: The identity that last modified the resource. + :paramtype last_modified_by: str + :keyword last_modified_by_type: The type of identity that last modified the resource. Known + values are: "User", "Application", "ManagedIdentity", and "Key". + :paramtype last_modified_by_type: str or ~azure.mgmt.databasewatcher.models.CreatedByType + :keyword last_modified_at: The timestamp of resource last modification (UTC). + :paramtype last_modified_at: ~datetime.datetime + """ + super().__init__(**kwargs) + self.created_by = created_by + self.created_by_type = created_by_type + self.created_at = created_at + self.last_modified_by = last_modified_by + self.last_modified_by_type = last_modified_by_type + self.last_modified_at = last_modified_at + + +class Target(ProxyResource): + """Concrete proxy resource types can be created by aliasing this type using a specific property + type. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar id: Fully qualified resource ID for the resource. E.g. + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}". + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData + :ivar target_type: Discriminator property for TargetProperties. + :vartype target_type: str + :ivar target_authentication_type: The type of authentication to use when connecting to a + target. Known values are: "Aad" and "Sql". + :vartype target_authentication_type: str or + ~azure.mgmt.databasewatcher.models.TargetAuthenticationType + :ivar target_vault: To use SQL authentication when connecting to targets, specify the vault + where the login name and password secrets are stored. + :vartype target_vault: ~azure.mgmt.databasewatcher.models.VaultSecret + :ivar connection_server_name: The FQDN host name of the server to use in the connection string + when connecting to a target. For example, for an Azure SQL logical server in the Azure + commercial cloud, the value might be 'sql-logical-server-22092780.database.windows.net'; for an + Azure SQL managed instance in the Azure commercial cloud, the value might be + 'sql-mi-39441134.767d5869f605.database.windows.net'. Port number and instance name must be + specified separately. + :vartype connection_server_name: str + :ivar provisioning_state: The provisioning state of the resource. Known values are: + "Succeeded", "Failed", and "Canceled". + :vartype provisioning_state: str or + ~azure.mgmt.databasewatcher.models.ResourceProvisioningState + """ + + _validation = { + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "system_data": {"readonly": True}, + "connection_server_name": {"max_length": 200}, + "provisioning_state": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "system_data": {"key": "systemData", "type": "SystemData"}, + "target_type": {"key": "properties.targetType", "type": "str"}, + "target_authentication_type": {"key": "properties.targetAuthenticationType", "type": "str"}, + "target_vault": {"key": "properties.targetVault", "type": "VaultSecret"}, + "connection_server_name": {"key": "properties.connectionServerName", "type": "str"}, + "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, + } + + def __init__( + self, + *, + target_authentication_type: Optional[Union[str, "_models.TargetAuthenticationType"]] = None, + target_vault: Optional["_models.VaultSecret"] = None, + connection_server_name: Optional[str] = None, + **kwargs: Any + ) -> None: + """ + :keyword target_authentication_type: The type of authentication to use when connecting to a + target. Known values are: "Aad" and "Sql". + :paramtype target_authentication_type: str or + ~azure.mgmt.databasewatcher.models.TargetAuthenticationType + :keyword target_vault: To use SQL authentication when connecting to targets, specify the vault + where the login name and password secrets are stored. + :paramtype target_vault: ~azure.mgmt.databasewatcher.models.VaultSecret + :keyword connection_server_name: The FQDN host name of the server to use in the connection + string when connecting to a target. For example, for an Azure SQL logical server in the Azure + commercial cloud, the value might be 'sql-logical-server-22092780.database.windows.net'; for an + Azure SQL managed instance in the Azure commercial cloud, the value might be + 'sql-mi-39441134.767d5869f605.database.windows.net'. Port number and instance name must be + specified separately. + :paramtype connection_server_name: str + """ + super().__init__(**kwargs) + self.target_type: Optional[str] = None + self.target_authentication_type = target_authentication_type + self.target_vault = target_vault + self.connection_server_name = connection_server_name + self.provisioning_state: Optional[Union[str, "_models.ResourceProvisioningState"]] = None + + +class TargetListResult(_serialization.Model): + """The response of a Target list operation. + + All required parameters must be populated in order to send to server. + + :ivar value: The Target items on this page. Required. + :vartype value: list[~azure.mgmt.databasewatcher.models.Target] + :ivar next_link: The link to the next page of items. + :vartype next_link: str + """ + + _validation = { + "value": {"required": True}, + } + + _attribute_map = { + "value": {"key": "value", "type": "[Target]"}, + "next_link": {"key": "nextLink", "type": "str"}, + } + + def __init__(self, *, value: List["_models.Target"], next_link: Optional[str] = None, **kwargs: Any) -> None: + """ + :keyword value: The Target items on this page. Required. + :paramtype value: list[~azure.mgmt.databasewatcher.models.Target] + :keyword next_link: The link to the next page of items. + :paramtype next_link: str + """ + super().__init__(**kwargs) + self.value = value + self.next_link = next_link + + +class TrackedResource(Resource): + """The resource model definition for an Azure Resource Manager tracked top level resource which + has 'tags' and a 'location'. + + Variables are only populated by the server, and will be ignored when sending a request. + + All required parameters must be populated in order to send to server. + + :ivar id: Fully qualified resource ID for the resource. E.g. + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}". + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + :ivar location: The geo-location where the resource lives. Required. + :vartype location: str + """ + + _validation = { + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "system_data": {"readonly": True}, + "location": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "system_data": {"key": "systemData", "type": "SystemData"}, + "tags": {"key": "tags", "type": "{str}"}, + "location": {"key": "location", "type": "str"}, + } + + def __init__(self, *, location: str, tags: Optional[Dict[str, str]] = None, **kwargs: Any) -> None: + """ + :keyword tags: Resource tags. + :paramtype tags: dict[str, str] + :keyword location: The geo-location where the resource lives. Required. + :paramtype location: str + """ + super().__init__(**kwargs) + self.tags = tags + self.location = location + + +class UserAssignedIdentity(_serialization.Model): + """User assigned identity properties. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar principal_id: The principal ID of the assigned identity. + :vartype principal_id: str + :ivar client_id: The client ID of the assigned identity. + :vartype client_id: str + """ + + _validation = { + "principal_id": {"readonly": True}, + "client_id": {"readonly": True}, + } + + _attribute_map = { + "principal_id": {"key": "principalId", "type": "str"}, + "client_id": {"key": "clientId", "type": "str"}, + } + + def __init__(self, **kwargs: Any) -> None: + """ """ + super().__init__(**kwargs) + self.principal_id: Optional[str] = None + self.client_id: Optional[str] = None + + +class ValidationIssue(_serialization.Model): + """The model of a health validation issue. + + Variables are only populated by the server, and will be ignored when sending a request. + + All required parameters must be populated in order to send to server. + + :ivar error_code: The error code of the issue. Required. + :vartype error_code: str + :ivar error_message: The error message of the issue. Required. + :vartype error_message: str + :ivar additional_details: The additional details for the issue. + :vartype additional_details: str + :ivar recommendation_message: The recommendation for resolving the issue. Required. + :vartype recommendation_message: str + :ivar recommendation_url: The URL related to resolving the issue. + :vartype recommendation_url: str + :ivar related_resource_id: The resource ID of the Azure resource related to the issue. + :vartype related_resource_id: str + :ivar related_resource_type: The type of the Azure resource related to the issue. + :vartype related_resource_type: str + """ + + _validation = { + "error_code": {"required": True, "readonly": True}, + "error_message": {"required": True, "readonly": True}, + "additional_details": {"readonly": True}, + "recommendation_message": {"required": True, "readonly": True}, + "recommendation_url": {"readonly": True}, + "related_resource_id": {"readonly": True}, + "related_resource_type": {"readonly": True}, + } + + _attribute_map = { + "error_code": {"key": "errorCode", "type": "str"}, + "error_message": {"key": "errorMessage", "type": "str"}, + "additional_details": {"key": "additionalDetails", "type": "str"}, + "recommendation_message": {"key": "recommendationMessage", "type": "str"}, + "recommendation_url": {"key": "recommendationUrl", "type": "str"}, + "related_resource_id": {"key": "relatedResourceId", "type": "str"}, + "related_resource_type": {"key": "relatedResourceType", "type": "str"}, + } + + def __init__(self, **kwargs: Any) -> None: + """ """ + super().__init__(**kwargs) + self.error_code: Optional[str] = None + self.error_message: Optional[str] = None + self.additional_details: Optional[str] = None + self.recommendation_message: Optional[str] = None + self.recommendation_url: Optional[str] = None + self.related_resource_id: Optional[str] = None + self.related_resource_type: Optional[str] = None + + +class VaultSecret(_serialization.Model): + """The vault specific details required if using SQL authentication to connect to a target. + + :ivar akv_resource_id: The Azure resource ID of the Key Vault instance storing database + authentication secrets. + :vartype akv_resource_id: str + :ivar akv_target_user: The path to the Key Vault secret storing the login name (aka user name, + aka account name) for authentication to a target. + :vartype akv_target_user: str + :ivar akv_target_password: The path to the Key Vault secret storing the password for + authentication to a target. + :vartype akv_target_password: str + """ + + _validation = { + "akv_target_user": {"pattern": r"^[a-zA-Z0-9-]{1,127}$"}, + "akv_target_password": {"pattern": r"^[a-zA-Z0-9-]{1,127}$"}, + } + + _attribute_map = { + "akv_resource_id": {"key": "akvResourceId", "type": "str"}, + "akv_target_user": {"key": "akvTargetUser", "type": "str"}, + "akv_target_password": {"key": "akvTargetPassword", "type": "str"}, + } + + def __init__( + self, + *, + akv_resource_id: Optional[str] = None, + akv_target_user: Optional[str] = None, + akv_target_password: Optional[str] = None, + **kwargs: Any + ) -> None: + """ + :keyword akv_resource_id: The Azure resource ID of the Key Vault instance storing database + authentication secrets. + :paramtype akv_resource_id: str + :keyword akv_target_user: The path to the Key Vault secret storing the login name (aka user + name, aka account name) for authentication to a target. + :paramtype akv_target_user: str + :keyword akv_target_password: The path to the Key Vault secret storing the password for + authentication to a target. + :paramtype akv_target_password: str + """ + super().__init__(**kwargs) + self.akv_resource_id = akv_resource_id + self.akv_target_user = akv_target_user + self.akv_target_password = akv_target_password + + +class Watcher(TrackedResource): + """The DatabaseWatcherProviderHub resource. + + Variables are only populated by the server, and will be ignored when sending a request. + + All required parameters must be populated in order to send to server. + + :ivar id: Fully qualified resource ID for the resource. E.g. + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}". + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: ~azure.mgmt.databasewatcher.models.SystemData + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + :ivar location: The geo-location where the resource lives. Required. + :vartype location: str + :ivar identity: The managed service identities assigned to this resource. + :vartype identity: ~azure.mgmt.databasewatcher.models.ManagedServiceIdentity + :ivar datastore: The data store for collected monitoring data. + :vartype datastore: ~azure.mgmt.databasewatcher.models.Datastore + :ivar status: The monitoring collection status of the watcher. Known values are: "Starting", + "Running", "Stopping", "Stopped", and "Deleting". + :vartype status: str or ~azure.mgmt.databasewatcher.models.WatcherStatus + :ivar provisioning_state: The provisioning state of the resource watcher. Known values are: + "Succeeded", "Failed", and "Canceled". + :vartype provisioning_state: str or + ~azure.mgmt.databasewatcher.models.DatabaseWatcherProvisioningState + :ivar default_alert_rule_identity_resource_id: The resource ID of a user-assigned managed + identity that will be assigned to a new alert rule. + :vartype default_alert_rule_identity_resource_id: str + """ + + _validation = { + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "system_data": {"readonly": True}, + "location": {"required": True}, + "status": {"readonly": True}, + "provisioning_state": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "system_data": {"key": "systemData", "type": "SystemData"}, + "tags": {"key": "tags", "type": "{str}"}, + "location": {"key": "location", "type": "str"}, + "identity": {"key": "identity", "type": "ManagedServiceIdentity"}, + "datastore": {"key": "properties.datastore", "type": "Datastore"}, + "status": {"key": "properties.status", "type": "str"}, + "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, + "default_alert_rule_identity_resource_id": { + "key": "properties.defaultAlertRuleIdentityResourceId", + "type": "str", + }, + } + + def __init__( + self, + *, + location: str, + tags: Optional[Dict[str, str]] = None, + identity: Optional["_models.ManagedServiceIdentity"] = None, + datastore: Optional["_models.Datastore"] = None, + default_alert_rule_identity_resource_id: Optional[str] = None, + **kwargs: Any + ) -> None: + """ + :keyword tags: Resource tags. + :paramtype tags: dict[str, str] + :keyword location: The geo-location where the resource lives. Required. + :paramtype location: str + :keyword identity: The managed service identities assigned to this resource. + :paramtype identity: ~azure.mgmt.databasewatcher.models.ManagedServiceIdentity + :keyword datastore: The data store for collected monitoring data. + :paramtype datastore: ~azure.mgmt.databasewatcher.models.Datastore + :keyword default_alert_rule_identity_resource_id: The resource ID of a user-assigned managed + identity that will be assigned to a new alert rule. + :paramtype default_alert_rule_identity_resource_id: str + """ + super().__init__(tags=tags, location=location, **kwargs) + self.identity = identity + self.datastore = datastore + self.status: Optional[Union[str, "_models.WatcherStatus"]] = None + self.provisioning_state: Optional[Union[str, "_models.DatabaseWatcherProvisioningState"]] = None + self.default_alert_rule_identity_resource_id = default_alert_rule_identity_resource_id + + +class WatcherListResult(_serialization.Model): + """The response of a Watcher list operation. + + All required parameters must be populated in order to send to server. + + :ivar value: The Watcher items on this page. Required. + :vartype value: list[~azure.mgmt.databasewatcher.models.Watcher] + :ivar next_link: The link to the next page of items. + :vartype next_link: str + """ + + _validation = { + "value": {"required": True}, + } + + _attribute_map = { + "value": {"key": "value", "type": "[Watcher]"}, + "next_link": {"key": "nextLink", "type": "str"}, + } + + def __init__(self, *, value: List["_models.Watcher"], next_link: Optional[str] = None, **kwargs: Any) -> None: + """ + :keyword value: The Watcher items on this page. Required. + :paramtype value: list[~azure.mgmt.databasewatcher.models.Watcher] + :keyword next_link: The link to the next page of items. + :paramtype next_link: str + """ + super().__init__(**kwargs) + self.value = value + self.next_link = next_link + + +class WatcherUpdate(_serialization.Model): + """The type used for update operations of the Watcher. + + :ivar identity: The managed service identities assigned to this resource. + :vartype identity: ~azure.mgmt.databasewatcher.models.ManagedServiceIdentity + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + :ivar datastore: The data store for collected monitoring data. + :vartype datastore: ~azure.mgmt.databasewatcher.models.DatastoreUpdate + :ivar default_alert_rule_identity_resource_id: The resource ID of a user-assigned managed + identity that will be assigned to a new alert rule. + :vartype default_alert_rule_identity_resource_id: str + """ + + _attribute_map = { + "identity": {"key": "identity", "type": "ManagedServiceIdentity"}, + "tags": {"key": "tags", "type": "{str}"}, + "datastore": {"key": "properties.datastore", "type": "DatastoreUpdate"}, + "default_alert_rule_identity_resource_id": { + "key": "properties.defaultAlertRuleIdentityResourceId", + "type": "str", + }, + } + + def __init__( + self, + *, + identity: Optional["_models.ManagedServiceIdentity"] = None, + tags: Optional[Dict[str, str]] = None, + datastore: Optional["_models.DatastoreUpdate"] = None, + default_alert_rule_identity_resource_id: Optional[str] = None, + **kwargs: Any + ) -> None: + """ + :keyword identity: The managed service identities assigned to this resource. + :paramtype identity: ~azure.mgmt.databasewatcher.models.ManagedServiceIdentity + :keyword tags: Resource tags. + :paramtype tags: dict[str, str] + :keyword datastore: The data store for collected monitoring data. + :paramtype datastore: ~azure.mgmt.databasewatcher.models.DatastoreUpdate + :keyword default_alert_rule_identity_resource_id: The resource ID of a user-assigned managed + identity that will be assigned to a new alert rule. + :paramtype default_alert_rule_identity_resource_id: str + """ + super().__init__(**kwargs) + self.identity = identity + self.tags = tags + self.datastore = datastore + self.default_alert_rule_identity_resource_id = default_alert_rule_identity_resource_id diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/__init__.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/__init__.py index c6940b5bbb72..bd3753b59109 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/__init__.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/__init__.py @@ -2,7 +2,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- # pylint: disable=wrong-import-position @@ -13,11 +13,11 @@ from ._patch import * # pylint: disable=unused-wildcard-import from ._operations import Operations # type: ignore -from ._operations import WatchersOperations # type: ignore -from ._operations import AlertRuleResourcesOperations # type: ignore -from ._operations import HealthValidationsOperations # type: ignore -from ._operations import TargetsOperations # type: ignore -from ._operations import SharedPrivateLinkResourcesOperations # type: ignore +from ._watchers_operations import WatchersOperations # type: ignore +from ._alert_rule_resources_operations import AlertRuleResourcesOperations # type: ignore +from ._health_validations_operations import HealthValidationsOperations # type: ignore +from ._shared_private_link_resources_operations import SharedPrivateLinkResourcesOperations # type: ignore +from ._targets_operations import TargetsOperations # type: ignore from ._patch import __all__ as _patch_all from ._patch import * @@ -28,8 +28,8 @@ "WatchersOperations", "AlertRuleResourcesOperations", "HealthValidationsOperations", - "TargetsOperations", "SharedPrivateLinkResourcesOperations", + "TargetsOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_alert_rule_resources_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_alert_rule_resources_operations.py new file mode 100644 index 000000000000..03c7cb2fc639 --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_alert_rule_resources_operations.py @@ -0,0 +1,562 @@ +# pylint: disable=line-too-long,useless-suppression +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from collections.abc import MutableMapping +from io import IOBase +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload +import urllib.parse + +from azure.core import PipelineClient +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) +from azure.core.paging import ItemPaged +from azure.core.pipeline import PipelineResponse +from azure.core.rest import HttpRequest, HttpResponse +from azure.core.tracing.decorator import distributed_trace +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat + +from .. import models as _models +from .._configuration import MicrosoftDatabaseWatcherConfiguration +from .._utils.serialization import Deserializer, Serializer + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_list_by_parent_request( + resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/alertRuleResources", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_get_request( + resource_group_name: str, watcher_name: str, alert_rule_resource_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/alertRuleResources/{alertRuleResourceName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + "alertRuleResourceName": _SERIALIZER.url( + "alert_rule_resource_name", + alert_rule_resource_name, + "str", + pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_.]{0,62}[a-zA-Z0-9_]{1}$", + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_create_or_update_request( + resource_group_name: str, watcher_name: str, alert_rule_resource_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/alertRuleResources/{alertRuleResourceName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + "alertRuleResourceName": _SERIALIZER.url( + "alert_rule_resource_name", + alert_rule_resource_name, + "str", + pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_.]{0,62}[a-zA-Z0-9_]{1}$", + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_delete_request( + resource_group_name: str, watcher_name: str, alert_rule_resource_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/alertRuleResources/{alertRuleResourceName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + "alertRuleResourceName": _SERIALIZER.url( + "alert_rule_resource_name", + alert_rule_resource_name, + "str", + pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_.]{0,62}[a-zA-Z0-9_]{1}$", + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) + + +class AlertRuleResourcesOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.databasewatcher.MicrosoftDatabaseWatcher`'s + :attr:`alert_rule_resources` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs): + input_args = list(args) + self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: MicrosoftDatabaseWatcherConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def list_by_parent( + self, resource_group_name: str, watcher_name: str, **kwargs: Any + ) -> Iterable["_models.AlertRuleResource"]: + """List AlertRuleResource resources by Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: An iterator like instance of either AlertRuleResource or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.databasewatcher.models.AlertRuleResource] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.AlertRuleResourceListResult] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_list_by_parent_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request + + def extract_data(pipeline_response): + deserialized = self._deserialize("AlertRuleResourceListResult", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.next_link or None, iter(list_of_elem) + + def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return ItemPaged(get_next, extract_data) + + @distributed_trace + def get( + self, resource_group_name: str, watcher_name: str, alert_rule_resource_name: str, **kwargs: Any + ) -> _models.AlertRuleResource: + """Get a AlertRuleResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param alert_rule_resource_name: The alert rule proxy resource name. Required. + :type alert_rule_resource_name: str + :return: AlertRuleResource or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.AlertRuleResource] = kwargs.pop("cls", None) + + _request = build_get_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + alert_rule_resource_name=alert_rule_resource_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("AlertRuleResource", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @overload + def create_or_update( + self, + resource_group_name: str, + watcher_name: str, + alert_rule_resource_name: str, + resource: _models.AlertRuleResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AlertRuleResource: + """Create a AlertRuleResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param alert_rule_resource_name: The alert rule proxy resource name. Required. + :type alert_rule_resource_name: str + :param resource: Resource create parameters. Required. + :type resource: ~azure.mgmt.databasewatcher.models.AlertRuleResource + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: AlertRuleResource or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + resource_group_name: str, + watcher_name: str, + alert_rule_resource_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AlertRuleResource: + """Create a AlertRuleResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param alert_rule_resource_name: The alert rule proxy resource name. Required. + :type alert_rule_resource_name: str + :param resource: Resource create parameters. Required. + :type resource: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: AlertRuleResource or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + watcher_name: str, + alert_rule_resource_name: str, + resource: Union[_models.AlertRuleResource, IO[bytes]], + **kwargs: Any + ) -> _models.AlertRuleResource: + """Create a AlertRuleResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param alert_rule_resource_name: The alert rule proxy resource name. Required. + :type alert_rule_resource_name: str + :param resource: Resource create parameters. Is either a AlertRuleResource type or a IO[bytes] + type. Required. + :type resource: ~azure.mgmt.databasewatcher.models.AlertRuleResource or IO[bytes] + :return: AlertRuleResource or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.AlertRuleResource] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(resource, (IOBase, bytes)): + _content = resource + else: + _json = self._serialize.body(resource, "AlertRuleResource") + + _request = build_create_or_update_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + alert_rule_resource_name=alert_rule_resource_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("AlertRuleResource", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def delete( # pylint: disable=inconsistent-return-statements + self, resource_group_name: str, watcher_name: str, alert_rule_resource_name: str, **kwargs: Any + ) -> None: + """Delete a AlertRuleResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param alert_rule_resource_name: The alert rule proxy resource name. Required. + :type alert_rule_resource_name: str + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_delete_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + alert_rule_resource_name=alert_rule_resource_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 204]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if cls: + return cls(pipeline_response, None, {}) # type: ignore diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_health_validations_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_health_validations_operations.py new file mode 100644 index 000000000000..90ee27db0e32 --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_health_validations_operations.py @@ -0,0 +1,445 @@ +# pylint: disable=line-too-long,useless-suppression +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from collections.abc import MutableMapping +from typing import Any, Callable, Dict, Iterable, Iterator, Optional, TypeVar, Union, cast +import urllib.parse + +from azure.core import PipelineClient +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, + map_error, +) +from azure.core.paging import ItemPaged +from azure.core.pipeline import PipelineResponse +from azure.core.polling import LROPoller, NoPolling, PollingMethod +from azure.core.rest import HttpRequest, HttpResponse +from azure.core.tracing.decorator import distributed_trace +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat +from azure.mgmt.core.polling.arm_polling import ARMPolling + +from .. import models as _models +from .._configuration import MicrosoftDatabaseWatcherConfiguration +from .._utils.serialization import Deserializer, Serializer + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_list_by_parent_request( + resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/healthValidations", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_get_request( + resource_group_name: str, watcher_name: str, health_validation_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/healthValidations/{healthValidationName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + "healthValidationName": _SERIALIZER.url( + "health_validation_name", + health_validation_name, + "str", + pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_.]{0,62}[a-zA-Z0-9_]{1}$", + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_start_validation_request( + resource_group_name: str, watcher_name: str, health_validation_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/healthValidations/{healthValidationName}/startValidation", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + "healthValidationName": _SERIALIZER.url( + "health_validation_name", + health_validation_name, + "str", + pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_.]{0,62}[a-zA-Z0-9_]{1}$", + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + + +class HealthValidationsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.databasewatcher.MicrosoftDatabaseWatcher`'s + :attr:`health_validations` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs): + input_args = list(args) + self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: MicrosoftDatabaseWatcherConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def list_by_parent( + self, resource_group_name: str, watcher_name: str, **kwargs: Any + ) -> Iterable["_models.HealthValidation"]: + """List HealthValidation resources by Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: An iterator like instance of either HealthValidation or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.databasewatcher.models.HealthValidation] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.HealthValidationListResult] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_list_by_parent_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request + + def extract_data(pipeline_response): + deserialized = self._deserialize("HealthValidationListResult", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.next_link or None, iter(list_of_elem) + + def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return ItemPaged(get_next, extract_data) + + @distributed_trace + def get( + self, resource_group_name: str, watcher_name: str, health_validation_name: str, **kwargs: Any + ) -> _models.HealthValidation: + """Get a HealthValidation. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param health_validation_name: The health validation resource name. Required. + :type health_validation_name: str + :return: HealthValidation or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.HealthValidation + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.HealthValidation] = kwargs.pop("cls", None) + + _request = build_get_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + health_validation_name=health_validation_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("HealthValidation", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + def _start_validation_initial( + self, resource_group_name: str, watcher_name: str, health_validation_name: str, **kwargs: Any + ) -> Iterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) + + _request = build_start_validation_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + health_validation_name=health_validation_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 202]: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 202: + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def begin_start_validation( + self, resource_group_name: str, watcher_name: str, health_validation_name: str, **kwargs: Any + ) -> LROPoller[_models.HealthValidation]: + """Starts health validation for a watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param health_validation_name: The health validation resource name. Required. + :type health_validation_name: str + :return: An instance of LROPoller that returns either HealthValidation or the result of + cls(response) + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.HealthValidation] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.HealthValidation] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = self._start_validation_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + health_validation_name=health_validation_name, + api_version=api_version, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): + deserialized = self._deserialize("HealthValidation", pipeline_response.http_response) + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + return deserialized + + if polling is True: + polling_method: PollingMethod = cast( + PollingMethod, ARMPolling(lro_delay, lro_options={"final-state-via": "location"}, **kwargs) + ) + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling + if cont_token: + return LROPoller[_models.HealthValidation].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return LROPoller[_models.HealthValidation]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_operations.py index 05716073510d..c72828469aec 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_operations.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_operations.py @@ -1,15 +1,12 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from io import IOBase -import json -import sys -from typing import Any, Callable, Dict, IO, Iterable, Iterator, List, Optional, TypeVar, Union, cast, overload +from collections.abc import MutableMapping +from typing import Any, Callable, Dict, Iterable, Optional, TypeVar import urllib.parse from azure.core import PipelineClient @@ -19,38 +16,27 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, - StreamClosedError, - StreamConsumedError, map_error, ) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse -from azure.core.polling import LROPoller, NoPolling, PollingMethod from azure.core.rest import HttpRequest, HttpResponse from azure.core.tracing.decorator import distributed_trace from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat -from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models -from .._configuration import DatabaseWatcherMgmtClientConfiguration -from .._model_base import SdkJSONEncoder, _deserialize, _failsafe_deserialize -from .._serialization import Deserializer, Serializer -from .._validation import api_version_validation +from .._configuration import MicrosoftDatabaseWatcherConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 9): - from collections.abc import MutableMapping -else: - from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] -JSON = MutableMapping[str, Any] # pylint: disable=unsubscriptable-object _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False -def build_operations_list_request(**kwargs: Any) -> HttpRequest: +def build_list_request(**kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) @@ -58,7 +44,7 @@ def build_operations_list_request(**kwargs: Any) -> HttpRequest: accept = _headers.pop("Accept", "application/json") # Construct URL - _url = "/providers/Microsoft.DatabaseWatcher/operations" + _url = kwargs.pop("template_url", "/providers/Microsoft.DatabaseWatcher/operations") # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -69,3560 +55,38 @@ def build_operations_list_request(**kwargs: Any) -> HttpRequest: return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_watchers_get_request( - resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_watchers_create_or_update_request( - resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_watchers_update_request( - resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_watchers_delete_request( - resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_watchers_list_by_resource_group_request( # pylint: disable=name-too-long - resource_group_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_watchers_list_by_subscription_request( # pylint: disable=name-too-long - subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/providers/Microsoft.DatabaseWatcher/watchers" - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_watchers_start_request( - resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/start" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_watchers_stop_request( - resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/stop" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_alert_rule_resources_get_request( - resource_group_name: str, watcher_name: str, alert_rule_resource_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/alertRuleResources/{alertRuleResourceName}" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - "alertRuleResourceName": _SERIALIZER.url("alert_rule_resource_name", alert_rule_resource_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_alert_rule_resources_create_or_update_request( # pylint: disable=name-too-long - resource_group_name: str, watcher_name: str, alert_rule_resource_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/alertRuleResources/{alertRuleResourceName}" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - "alertRuleResourceName": _SERIALIZER.url("alert_rule_resource_name", alert_rule_resource_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_alert_rule_resources_delete_request( # pylint: disable=name-too-long - resource_group_name: str, watcher_name: str, alert_rule_resource_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/alertRuleResources/{alertRuleResourceName}" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - "alertRuleResourceName": _SERIALIZER.url("alert_rule_resource_name", alert_rule_resource_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_alert_rule_resources_list_by_parent_request( # pylint: disable=name-too-long - resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/alertRuleResources" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_health_validations_get_request( - resource_group_name: str, watcher_name: str, health_validation_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/healthValidations/{healthValidationName}" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - "healthValidationName": _SERIALIZER.url("health_validation_name", health_validation_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_health_validations_list_by_parent_request( # pylint: disable=name-too-long - resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/healthValidations" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_health_validations_start_validation_request( # pylint: disable=name-too-long - resource_group_name: str, watcher_name: str, health_validation_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/healthValidations/{healthValidationName}/startValidation" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - "healthValidationName": _SERIALIZER.url("health_validation_name", health_validation_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_targets_get_request( - resource_group_name: str, watcher_name: str, target_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/targets/{targetName}" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - "targetName": _SERIALIZER.url("target_name", target_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_targets_create_or_update_request( - resource_group_name: str, watcher_name: str, target_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/targets/{targetName}" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - "targetName": _SERIALIZER.url("target_name", target_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_targets_delete_request( - resource_group_name: str, watcher_name: str, target_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/targets/{targetName}" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - "targetName": _SERIALIZER.url("target_name", target_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_targets_list_by_watcher_request( - resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/targets" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_shared_private_link_resources_get_request( # pylint: disable=name-too-long - resource_group_name: str, - watcher_name: str, - shared_private_link_resource_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/sharedPrivateLinkResources/{sharedPrivateLinkResourceName}" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - "sharedPrivateLinkResourceName": _SERIALIZER.url( - "shared_private_link_resource_name", shared_private_link_resource_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_shared_private_link_resources_create_request( # pylint: disable=name-too-long - resource_group_name: str, - watcher_name: str, - shared_private_link_resource_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/sharedPrivateLinkResources/{sharedPrivateLinkResourceName}" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - "sharedPrivateLinkResourceName": _SERIALIZER.url( - "shared_private_link_resource_name", shared_private_link_resource_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_shared_private_link_resources_delete_request( # pylint: disable=name-too-long - resource_group_name: str, - watcher_name: str, - shared_private_link_resource_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/sharedPrivateLinkResources/{sharedPrivateLinkResourceName}" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - "sharedPrivateLinkResourceName": _SERIALIZER.url( - "shared_private_link_resource_name", shared_private_link_resource_name, "str" - ), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_shared_private_link_resources_list_by_watcher_request( # pylint: disable=name-too-long - resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/sharedPrivateLinkResources" # pylint: disable=line-too-long - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.databasewatcher.DatabaseWatcherMgmtClient`'s - :attr:`operations` attribute. - """ - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: DatabaseWatcherMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace - def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: - """List the operations for the provider. - - :return: An iterator like instance of Operation - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.databasewatcher.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[List[_models.Operation]] = kwargs.pop("cls", None) - - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_operations_list_request( - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - return _request - - def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.Operation], deserialized["value"]) - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - -class WatchersOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.databasewatcher.DatabaseWatcherMgmtClient`'s - :attr:`watchers` attribute. - """ - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: DatabaseWatcherMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace - def get(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> _models.Watcher: - """Get a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: Watcher. The Watcher is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.Watcher - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) - - _request = build_watchers_get_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - if _stream: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() - else: - deserialized = _deserialize(_models.Watcher, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - def _create_or_update_initial( - self, - resource_group_name: str, - watcher_name: str, - resource: Union[_models.Watcher, JSON, IO[bytes]], - **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _content = None - if isinstance(resource, (IOBase, bytes)): - _content = resource - else: - _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore - - _request = build_watchers_create_or_update_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - content_type=content_type, - api_version=self._config.api_version, - content=_content, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 201: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - watcher_name: str, - resource: _models.Watcher, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Watcher]: - """Create a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param resource: Resource create parameters. Required. - :type resource: ~azure.mgmt.databasewatcher.models.Watcher - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - watcher_name: str, - resource: JSON, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Watcher]: - """Create a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param resource: Resource create parameters. Required. - :type resource: JSON - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - watcher_name: str, - resource: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Watcher]: - """Create a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param resource: Resource create parameters. Required. - :type resource: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_create_or_update( - self, - resource_group_name: str, - watcher_name: str, - resource: Union[_models.Watcher, JSON, IO[bytes]], - **kwargs: Any - ) -> LROPoller[_models.Watcher]: - """Create a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param resource: Resource create parameters. Is one of the following types: Watcher, JSON, - IO[bytes] Required. - :type resource: ~azure.mgmt.databasewatcher.models.Watcher or JSON or IO[bytes] - :return: An instance of LROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._create_or_update_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - resource=resource, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - response = pipeline_response.http_response - deserialized = _deserialize(_models.Watcher, response.json()) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: PollingMethod = cast( - PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.Watcher].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.Watcher]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - def _update_initial( - self, - resource_group_name: str, - watcher_name: str, - properties: Union[_models.WatcherUpdate, JSON, IO[bytes]], - **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _content = None - if isinstance(properties, (IOBase, bytes)): - _content = properties - else: - _content = json.dumps(properties, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore - - _request = build_watchers_update_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - content_type=content_type, - api_version=self._config.api_version, - content=_content, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_update( - self, - resource_group_name: str, - watcher_name: str, - properties: _models.WatcherUpdate, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Watcher]: - """Update a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param properties: The resource properties to be updated. Required. - :type properties: ~azure.mgmt.databasewatcher.models.WatcherUpdate - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_update( - self, - resource_group_name: str, - watcher_name: str, - properties: JSON, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Watcher]: - """Update a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param properties: The resource properties to be updated. Required. - :type properties: JSON - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_update( - self, - resource_group_name: str, - watcher_name: str, - properties: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.Watcher]: - """Update a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param properties: The resource properties to be updated. Required. - :type properties: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_update( - self, - resource_group_name: str, - watcher_name: str, - properties: Union[_models.WatcherUpdate, JSON, IO[bytes]], - **kwargs: Any - ) -> LROPoller[_models.Watcher]: - """Update a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param properties: The resource properties to be updated. Is one of the following types: - WatcherUpdate, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.databasewatcher.models.WatcherUpdate or JSON or IO[bytes] - :return: An instance of LROPoller that returns Watcher. The Watcher is compatible with - MutableMapping - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._update_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - properties=properties, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - response = pipeline_response.http_response - deserialized = _deserialize(_models.Watcher, response.json()) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: PollingMethod = cast( - PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.Watcher].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.Watcher]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - def _delete_initial(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_watchers_delete_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202, 204]: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> LROPoller[None]: - """Delete a Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: An instance of LROPoller that returns None - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: PollingMethod = cast( - PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Iterable["_models.Watcher"]: - """List Watcher resources by resource group. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :return: An iterator like instance of Watcher - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[List[_models.Watcher]] = kwargs.pop("cls", None) - - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_watchers_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - return _request - - def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.Watcher], deserialized["value"]) - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @distributed_trace - def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.Watcher"]: - """List Watcher resources by subscription ID. - - :return: An iterator like instance of Watcher - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.databasewatcher.models.Watcher] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[List[_models.Watcher]] = kwargs.pop("cls", None) - - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_watchers_list_by_subscription_request( - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - return _request - - def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.Watcher], deserialized["value"]) - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - def _start_initial(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_watchers_start_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_start(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> LROPoller[None]: - """The action to start monitoring all targets configured for a database watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: An instance of LROPoller that returns None - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._start_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: PollingMethod = cast( - PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - def _stop_initial(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> Iterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_watchers_stop_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_stop(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> LROPoller[None]: - """The action to stop monitoring all targets configured for a database watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: An instance of LROPoller that returns None - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._stop_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: PollingMethod = cast( - PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - -class AlertRuleResourcesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.databasewatcher.DatabaseWatcherMgmtClient`'s - :attr:`alert_rule_resources` attribute. - """ - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: DatabaseWatcherMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace - @api_version_validation( - method_added_on="2024-07-19-preview", - params_added_on={ - "2024-07-19-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "watcher_name", - "alert_rule_resource_name", - "accept", - ] - }, - ) - def get( - self, resource_group_name: str, watcher_name: str, alert_rule_resource_name: str, **kwargs: Any - ) -> _models.AlertRuleResource: - """Get a AlertRuleResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param alert_rule_resource_name: The alert rule proxy resource name. Required. - :type alert_rule_resource_name: str - :return: AlertRuleResource. The AlertRuleResource is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.AlertRuleResource] = kwargs.pop("cls", None) - - _request = build_alert_rule_resources_get_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - alert_rule_resource_name=alert_rule_resource_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - if _stream: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() - else: - deserialized = _deserialize(_models.AlertRuleResource, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - alert_rule_resource_name: str, - resource: _models.AlertRuleResource, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.AlertRuleResource: - """Create a AlertRuleResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param alert_rule_resource_name: The alert rule proxy resource name. Required. - :type alert_rule_resource_name: str - :param resource: Resource create parameters. Required. - :type resource: ~azure.mgmt.databasewatcher.models.AlertRuleResource - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: AlertRuleResource. The AlertRuleResource is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - alert_rule_resource_name: str, - resource: JSON, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.AlertRuleResource: - """Create a AlertRuleResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param alert_rule_resource_name: The alert rule proxy resource name. Required. - :type alert_rule_resource_name: str - :param resource: Resource create parameters. Required. - :type resource: JSON - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: AlertRuleResource. The AlertRuleResource is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - alert_rule_resource_name: str, - resource: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.AlertRuleResource: - """Create a AlertRuleResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param alert_rule_resource_name: The alert rule proxy resource name. Required. - :type alert_rule_resource_name: str - :param resource: Resource create parameters. Required. - :type resource: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: AlertRuleResource. The AlertRuleResource is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - @api_version_validation( - method_added_on="2024-07-19-preview", - params_added_on={ - "2024-07-19-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "watcher_name", - "alert_rule_resource_name", - "content_type", - "accept", - ] - }, - ) - def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - alert_rule_resource_name: str, - resource: Union[_models.AlertRuleResource, JSON, IO[bytes]], - **kwargs: Any - ) -> _models.AlertRuleResource: - """Create a AlertRuleResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param alert_rule_resource_name: The alert rule proxy resource name. Required. - :type alert_rule_resource_name: str - :param resource: Resource create parameters. Is one of the following types: AlertRuleResource, - JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.databasewatcher.models.AlertRuleResource or JSON or IO[bytes] - :return: AlertRuleResource. The AlertRuleResource is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.AlertRuleResource - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.AlertRuleResource] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _content = None - if isinstance(resource, (IOBase, bytes)): - _content = resource - else: - _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore - - _request = build_alert_rule_resources_create_or_update_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - alert_rule_resource_name=alert_rule_resource_name, - subscription_id=self._config.subscription_id, - content_type=content_type, - api_version=self._config.api_version, - content=_content, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - if _stream: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() - else: - deserialized = _deserialize(_models.AlertRuleResource, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - @api_version_validation( - method_added_on="2024-07-19-preview", - params_added_on={ - "2024-07-19-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "watcher_name", - "alert_rule_resource_name", - "accept", - ] - }, - ) - def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, watcher_name: str, alert_rule_resource_name: str, **kwargs: Any - ) -> None: - """Delete a AlertRuleResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param alert_rule_resource_name: The alert rule proxy resource name. Required. - :type alert_rule_resource_name: str - :return: None - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_alert_rule_resources_delete_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - alert_rule_resource_name=alert_rule_resource_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace - @api_version_validation( - method_added_on="2024-07-19-preview", - params_added_on={ - "2024-07-19-preview": ["api_version", "subscription_id", "resource_group_name", "watcher_name", "accept"] - }, - ) - def list_by_parent( - self, resource_group_name: str, watcher_name: str, **kwargs: Any - ) -> Iterable["_models.AlertRuleResource"]: - """List AlertRuleResource resources by Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: An iterator like instance of AlertRuleResource - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.databasewatcher.models.AlertRuleResource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[List[_models.AlertRuleResource]] = kwargs.pop("cls", None) - - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_alert_rule_resources_list_by_parent_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - return _request - - def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.AlertRuleResource], deserialized["value"]) - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - -class HealthValidationsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.databasewatcher.DatabaseWatcherMgmtClient`'s - :attr:`health_validations` attribute. - """ - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: DatabaseWatcherMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace - @api_version_validation( - method_added_on="2024-10-01-preview", - params_added_on={ - "2024-10-01-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "watcher_name", - "health_validation_name", - "accept", - ] - }, - ) - def get( - self, resource_group_name: str, watcher_name: str, health_validation_name: str, **kwargs: Any - ) -> _models.HealthValidation: - """Get a HealthValidation. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param health_validation_name: The health validation resource name. Required. - :type health_validation_name: str - :return: HealthValidation. The HealthValidation is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.HealthValidation - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.HealthValidation] = kwargs.pop("cls", None) - - _request = build_health_validations_get_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - health_validation_name=health_validation_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - if _stream: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() - else: - deserialized = _deserialize(_models.HealthValidation, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - @api_version_validation( - method_added_on="2024-10-01-preview", - params_added_on={ - "2024-10-01-preview": ["api_version", "subscription_id", "resource_group_name", "watcher_name", "accept"] - }, - ) - def list_by_parent( - self, resource_group_name: str, watcher_name: str, **kwargs: Any - ) -> Iterable["_models.HealthValidation"]: - """List HealthValidation resources by Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: An iterator like instance of HealthValidation - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.databasewatcher.models.HealthValidation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[List[_models.HealthValidation]] = kwargs.pop("cls", None) - - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_health_validations_list_by_parent_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - return _request - - def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.HealthValidation], deserialized["value"]) - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - @api_version_validation( - method_added_on="2024-10-01-preview", - params_added_on={ - "2024-10-01-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "watcher_name", - "health_validation_name", - "accept", - ] - }, - ) - def _start_validation_initial( - self, resource_group_name: str, watcher_name: str, health_validation_name: str, **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_health_validations_start_validation_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - health_validation_name=health_validation_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - @api_version_validation( - method_added_on="2024-10-01-preview", - params_added_on={ - "2024-10-01-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "watcher_name", - "health_validation_name", - "accept", - ] - }, - ) - def begin_start_validation( - self, resource_group_name: str, watcher_name: str, health_validation_name: str, **kwargs: Any - ) -> LROPoller[_models.HealthValidation]: - """Starts health validation for a watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param health_validation_name: The health validation resource name. Required. - :type health_validation_name: str - :return: An instance of LROPoller that returns HealthValidation. The HealthValidation is - compatible with MutableMapping - :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.HealthValidation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.HealthValidation] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._start_validation_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - health_validation_name=health_validation_name, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - response_headers = {} - response = pipeline_response.http_response - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = _deserialize(_models.HealthValidation, response.json()) - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - return deserialized - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: PollingMethod = cast( - PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.HealthValidation].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.HealthValidation]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - -class TargetsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.databasewatcher.DatabaseWatcherMgmtClient`'s - :attr:`targets` attribute. - """ - - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: DatabaseWatcherMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace - def get(self, resource_group_name: str, watcher_name: str, target_name: str, **kwargs: Any) -> _models.Target: - """Get a Target. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param target_name: The target resource name. Required. - :type target_name: str - :return: Target. The Target is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.Target - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.Target] = kwargs.pop("cls", None) - - _request = build_targets_get_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - target_name=target_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - if _stream: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() - else: - deserialized = _deserialize(_models.Target, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @overload - def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - target_name: str, - resource: _models.Target, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Target: - """Create a Target. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param target_name: The target resource name. Required. - :type target_name: str - :param resource: Resource create parameters. Required. - :type resource: ~azure.mgmt.databasewatcher.models.Target - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Target. The Target is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.Target - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - target_name: str, - resource: JSON, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Target: - """Create a Target. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param target_name: The target resource name. Required. - :type target_name: str - :param resource: Resource create parameters. Required. - :type resource: JSON - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: Target. The Target is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.Target - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - target_name: str, - resource: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.Target: - """Create a Target. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param target_name: The target resource name. Required. - :type target_name: str - :param resource: Resource create parameters. Required. - :type resource: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: Target. The Target is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.Target - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def create_or_update( - self, - resource_group_name: str, - watcher_name: str, - target_name: str, - resource: Union[_models.Target, JSON, IO[bytes]], - **kwargs: Any - ) -> _models.Target: - """Create a Target. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param target_name: The target resource name. Required. - :type target_name: str - :param resource: Resource create parameters. Is one of the following types: Target, JSON, - IO[bytes] Required. - :type resource: ~azure.mgmt.databasewatcher.models.Target or JSON or IO[bytes] - :return: Target. The Target is compatible with MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.Target - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.Target] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _content = None - if isinstance(resource, (IOBase, bytes)): - _content = resource - else: - _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore - - _request = build_targets_create_or_update_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - target_name=target_name, - subscription_id=self._config.subscription_id, - content_type=content_type, - api_version=self._config.api_version, - content=_content, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - if _stream: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() - else: - deserialized = _deserialize(_models.Target, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, watcher_name: str, target_name: str, **kwargs: Any - ) -> None: - """Delete a Target. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param target_name: The target resource name. Required. - :type target_name: str - :return: None - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_targets_delete_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - target_name=target_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - @distributed_trace - def list_by_watcher(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> Iterable["_models.Target"]: - """List Target resources by Watcher. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: An iterator like instance of Target - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.databasewatcher.models.Target] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[List[_models.Target]] = kwargs.pop("cls", None) - - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_targets_list_by_watcher_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - return _request - - def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.Target], deserialized["value"]) - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - -class SharedPrivateLinkResourcesOperations: +class Operations: """ .. warning:: **DO NOT** instantiate this class directly. Instead, you should access the following operations through - :class:`~azure.mgmt.databasewatcher.DatabaseWatcherMgmtClient`'s - :attr:`shared_private_link_resources` attribute. + :class:`~azure.mgmt.databasewatcher.MicrosoftDatabaseWatcher`'s + :attr:`operations` attribute. """ + models = _models + def __init__(self, *args, **kwargs): input_args = list(args) self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: DatabaseWatcherMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._config: MicrosoftDatabaseWatcherConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace - def get( - self, resource_group_name: str, watcher_name: str, shared_private_link_resource_name: str, **kwargs: Any - ) -> _models.SharedPrivateLinkResource: - """Get a SharedPrivateLinkResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param shared_private_link_resource_name: The Shared Private Link resource name. Required. - :type shared_private_link_resource_name: str - :return: SharedPrivateLinkResource. The SharedPrivateLinkResource is compatible with - MutableMapping - :rtype: ~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.SharedPrivateLinkResource] = kwargs.pop("cls", None) - - _request = build_shared_private_link_resources_get_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - shared_private_link_resource_name=shared_private_link_resource_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - if _stream: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() - else: - deserialized = _deserialize(_models.SharedPrivateLinkResource, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - def _create_initial( - self, - resource_group_name: str, - watcher_name: str, - shared_private_link_resource_name: str, - resource: Union[_models.SharedPrivateLinkResource, JSON, IO[bytes]], - **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _content = None - if isinstance(resource, (IOBase, bytes)): - _content = resource - else: - _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore - - _request = build_shared_private_link_resources_create_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - shared_private_link_resource_name=shared_private_link_resource_name, - subscription_id=self._config.subscription_id, - content_type=content_type, - api_version=self._config.api_version, - content=_content, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 201: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_create( - self, - resource_group_name: str, - watcher_name: str, - shared_private_link_resource_name: str, - resource: _models.SharedPrivateLinkResource, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.SharedPrivateLinkResource]: - """Create a SharedPrivateLinkResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param shared_private_link_resource_name: The Shared Private Link resource name. Required. - :type shared_private_link_resource_name: str - :param resource: Resource create parameters. Required. - :type resource: ~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns SharedPrivateLinkResource. The - SharedPrivateLinkResource is compatible with MutableMapping - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create( - self, - resource_group_name: str, - watcher_name: str, - shared_private_link_resource_name: str, - resource: JSON, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.SharedPrivateLinkResource]: - """Create a SharedPrivateLinkResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param shared_private_link_resource_name: The Shared Private Link resource name. Required. - :type shared_private_link_resource_name: str - :param resource: Resource create parameters. Required. - :type resource: JSON - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns SharedPrivateLinkResource. The - SharedPrivateLinkResource is compatible with MutableMapping - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create( - self, - resource_group_name: str, - watcher_name: str, - shared_private_link_resource_name: str, - resource: IO[bytes], - *, - content_type: str = "application/json", - **kwargs: Any - ) -> LROPoller[_models.SharedPrivateLinkResource]: - """Create a SharedPrivateLinkResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param shared_private_link_resource_name: The Shared Private Link resource name. Required. - :type shared_private_link_resource_name: str - :param resource: Resource create parameters. Required. - :type resource: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: An instance of LROPoller that returns SharedPrivateLinkResource. The - SharedPrivateLinkResource is compatible with MutableMapping - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def begin_create( - self, - resource_group_name: str, - watcher_name: str, - shared_private_link_resource_name: str, - resource: Union[_models.SharedPrivateLinkResource, JSON, IO[bytes]], - **kwargs: Any - ) -> LROPoller[_models.SharedPrivateLinkResource]: - """Create a SharedPrivateLinkResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param shared_private_link_resource_name: The Shared Private Link resource name. Required. - :type shared_private_link_resource_name: str - :param resource: Resource create parameters. Is one of the following types: - SharedPrivateLinkResource, JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource or JSON or - IO[bytes] - :return: An instance of LROPoller that returns SharedPrivateLinkResource. The - SharedPrivateLinkResource is compatible with MutableMapping - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.SharedPrivateLinkResource] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._create_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - shared_private_link_resource_name=shared_private_link_resource_name, - resource=resource, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - response = pipeline_response.http_response - deserialized = _deserialize(_models.SharedPrivateLinkResource, response.json()) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: PollingMethod = cast( - PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.SharedPrivateLinkResource].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.SharedPrivateLinkResource]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - def _delete_initial( - self, resource_group_name: str, watcher_name: str, shared_private_link_resource_name: str, **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_shared_private_link_resources_delete_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - shared_private_link_resource_name=shared_private_link_resource_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202, 204]: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def begin_delete( - self, resource_group_name: str, watcher_name: str, shared_private_link_resource_name: str, **kwargs: Any - ) -> LROPoller[None]: - """Delete a SharedPrivateLinkResource. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :param shared_private_link_resource_name: The Shared Private Link resource name. Required. - :type shared_private_link_resource_name: str - :return: An instance of LROPoller that returns None - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - shared_private_link_resource_name=shared_private_link_resource_name, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: PollingMethod = cast( - PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - def list_by_watcher( - self, resource_group_name: str, watcher_name: str, **kwargs: Any - ) -> Iterable["_models.SharedPrivateLinkResource"]: - """List SharedPrivateLinkResource resources by Watcher. + def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: + """List the operations for the provider. - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param watcher_name: The database watcher name. Required. - :type watcher_name: str - :return: An iterator like instance of SharedPrivateLinkResource - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] + :return: An iterator like instance of either Operation or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.databasewatcher.models.Operation] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - cls: ClsType[List[_models.SharedPrivateLinkResource]] = kwargs.pop("cls", None) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) error_map: MutableMapping = { 401: ClientAuthenticationError, @@ -3635,20 +99,12 @@ def list_by_watcher( def prepare_request(next_link=None): if not next_link: - _request = build_shared_private_link_resources_list_by_watcher_request( - resource_group_name=resource_group_name, - watcher_name=watcher_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, + _request = build_list_request( + api_version=api_version, headers=_headers, params=_params, ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -3663,21 +119,16 @@ def prepare_request(next_link=None): _request = HttpRequest( "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - + _request.url = self._client.format_url(_request.url) + _request.method = "GET" return _request def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.SharedPrivateLinkResource], deserialized["value"]) + deserialized = self._deserialize("OperationListResult", pipeline_response) + list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, iter(list_of_elem) + return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): _request = prepare_request(next_link) @@ -3690,7 +141,7 @@ def get_next(next_link=None): if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize(_models.ErrorResponse, response.json()) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) return pipeline_response diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_shared_private_link_resources_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_shared_private_link_resources_operations.py new file mode 100644 index 000000000000..fdda5cfb8eba --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_shared_private_link_resources_operations.py @@ -0,0 +1,713 @@ +# pylint: disable=line-too-long,useless-suppression +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from collections.abc import MutableMapping +from io import IOBase +from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, TypeVar, Union, cast, overload +import urllib.parse + +from azure.core import PipelineClient +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, + map_error, +) +from azure.core.paging import ItemPaged +from azure.core.pipeline import PipelineResponse +from azure.core.polling import LROPoller, NoPolling, PollingMethod +from azure.core.rest import HttpRequest, HttpResponse +from azure.core.tracing.decorator import distributed_trace +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat +from azure.mgmt.core.polling.arm_polling import ARMPolling + +from .. import models as _models +from .._configuration import MicrosoftDatabaseWatcherConfiguration +from .._utils.serialization import Deserializer, Serializer + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_list_by_watcher_request( + resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/sharedPrivateLinkResources", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_get_request( + resource_group_name: str, + watcher_name: str, + shared_private_link_resource_name: str, + subscription_id: str, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/sharedPrivateLinkResources/{sharedPrivateLinkResourceName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + "sharedPrivateLinkResourceName": _SERIALIZER.url( + "shared_private_link_resource_name", + shared_private_link_resource_name, + "str", + pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_.]{0,62}[a-zA-Z0-9_]{1}$", + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_create_request( + resource_group_name: str, + watcher_name: str, + shared_private_link_resource_name: str, + subscription_id: str, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/sharedPrivateLinkResources/{sharedPrivateLinkResourceName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + "sharedPrivateLinkResourceName": _SERIALIZER.url( + "shared_private_link_resource_name", + shared_private_link_resource_name, + "str", + pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_.]{0,62}[a-zA-Z0-9_]{1}$", + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_delete_request( + resource_group_name: str, + watcher_name: str, + shared_private_link_resource_name: str, + subscription_id: str, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/sharedPrivateLinkResources/{sharedPrivateLinkResourceName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + "sharedPrivateLinkResourceName": _SERIALIZER.url( + "shared_private_link_resource_name", + shared_private_link_resource_name, + "str", + pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_.]{0,62}[a-zA-Z0-9_]{1}$", + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) + + +class SharedPrivateLinkResourcesOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.databasewatcher.MicrosoftDatabaseWatcher`'s + :attr:`shared_private_link_resources` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs): + input_args = list(args) + self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: MicrosoftDatabaseWatcherConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def list_by_watcher( + self, resource_group_name: str, watcher_name: str, **kwargs: Any + ) -> Iterable["_models.SharedPrivateLinkResource"]: + """List SharedPrivateLinkResource resources by Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: An iterator like instance of either SharedPrivateLinkResource or the result of + cls(response) + :rtype: + ~azure.core.paging.ItemPaged[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.SharedPrivateLinkResourceListResult] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_list_by_watcher_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request + + def extract_data(pipeline_response): + deserialized = self._deserialize("SharedPrivateLinkResourceListResult", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.next_link or None, iter(list_of_elem) + + def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return ItemPaged(get_next, extract_data) + + @distributed_trace + def get( + self, resource_group_name: str, watcher_name: str, shared_private_link_resource_name: str, **kwargs: Any + ) -> _models.SharedPrivateLinkResource: + """Get a SharedPrivateLinkResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param shared_private_link_resource_name: The Shared Private Link resource name. Required. + :type shared_private_link_resource_name: str + :return: SharedPrivateLinkResource or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.SharedPrivateLinkResource] = kwargs.pop("cls", None) + + _request = build_get_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + shared_private_link_resource_name=shared_private_link_resource_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("SharedPrivateLinkResource", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + def _create_initial( + self, + resource_group_name: str, + watcher_name: str, + shared_private_link_resource_name: str, + resource: Union[_models.SharedPrivateLinkResource, IO[bytes]], + **kwargs: Any + ) -> Iterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(resource, (IOBase, bytes)): + _content = resource + else: + _json = self._serialize.body(resource, "SharedPrivateLinkResource") + + _request = build_create_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + shared_private_link_resource_name=shared_private_link_resource_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 201: + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @overload + def begin_create( + self, + resource_group_name: str, + watcher_name: str, + shared_private_link_resource_name: str, + resource: _models.SharedPrivateLinkResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[_models.SharedPrivateLinkResource]: + """Create a SharedPrivateLinkResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param shared_private_link_resource_name: The Shared Private Link resource name. Required. + :type shared_private_link_resource_name: str + :param resource: Resource create parameters. Required. + :type resource: ~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: An instance of LROPoller that returns either SharedPrivateLinkResource or the result + of cls(response) + :rtype: + ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def begin_create( + self, + resource_group_name: str, + watcher_name: str, + shared_private_link_resource_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[_models.SharedPrivateLinkResource]: + """Create a SharedPrivateLinkResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param shared_private_link_resource_name: The Shared Private Link resource name. Required. + :type shared_private_link_resource_name: str + :param resource: Resource create parameters. Required. + :type resource: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: An instance of LROPoller that returns either SharedPrivateLinkResource or the result + of cls(response) + :rtype: + ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def begin_create( + self, + resource_group_name: str, + watcher_name: str, + shared_private_link_resource_name: str, + resource: Union[_models.SharedPrivateLinkResource, IO[bytes]], + **kwargs: Any + ) -> LROPoller[_models.SharedPrivateLinkResource]: + """Create a SharedPrivateLinkResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param shared_private_link_resource_name: The Shared Private Link resource name. Required. + :type shared_private_link_resource_name: str + :param resource: Resource create parameters. Is either a SharedPrivateLinkResource type or a + IO[bytes] type. Required. + :type resource: ~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource or IO[bytes] + :return: An instance of LROPoller that returns either SharedPrivateLinkResource or the result + of cls(response) + :rtype: + ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.SharedPrivateLinkResource] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.SharedPrivateLinkResource] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = self._create_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + shared_private_link_resource_name=shared_private_link_resource_name, + resource=resource, + api_version=api_version, + content_type=content_type, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): + deserialized = self._deserialize("SharedPrivateLinkResource", pipeline_response.http_response) + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + return deserialized + + if polling is True: + polling_method: PollingMethod = cast( + PollingMethod, ARMPolling(lro_delay, lro_options={"final-state-via": "azure-async-operation"}, **kwargs) + ) + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling + if cont_token: + return LROPoller[_models.SharedPrivateLinkResource].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return LROPoller[_models.SharedPrivateLinkResource]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) + + def _delete_initial( + self, resource_group_name: str, watcher_name: str, shared_private_link_resource_name: str, **kwargs: Any + ) -> Iterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) + + _request = build_delete_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + shared_private_link_resource_name=shared_private_link_resource_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202, 204]: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 202: + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def begin_delete( + self, resource_group_name: str, watcher_name: str, shared_private_link_resource_name: str, **kwargs: Any + ) -> LROPoller[None]: + """Delete a SharedPrivateLinkResource. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param shared_private_link_resource_name: The Shared Private Link resource name. Required. + :type shared_private_link_resource_name: str + :return: An instance of LROPoller that returns either None or the result of cls(response) + :rtype: ~azure.core.polling.LROPoller[None] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[None] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = self._delete_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + shared_private_link_resource_name=shared_private_link_resource_name, + api_version=api_version, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements + if cls: + return cls(pipeline_response, None, {}) # type: ignore + + if polling is True: + polling_method: PollingMethod = cast( + PollingMethod, ARMPolling(lro_delay, lro_options={"final-state-via": "location"}, **kwargs) + ) + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling + if cont_token: + return LROPoller[None].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_targets_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_targets_operations.py new file mode 100644 index 000000000000..42711945bbad --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_targets_operations.py @@ -0,0 +1,549 @@ +# pylint: disable=line-too-long,useless-suppression +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from collections.abc import MutableMapping +from io import IOBase +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload +import urllib.parse + +from azure.core import PipelineClient +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) +from azure.core.paging import ItemPaged +from azure.core.pipeline import PipelineResponse +from azure.core.rest import HttpRequest, HttpResponse +from azure.core.tracing.decorator import distributed_trace +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat + +from .. import models as _models +from .._configuration import MicrosoftDatabaseWatcherConfiguration +from .._utils.serialization import Deserializer, Serializer + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_list_by_watcher_request( + resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/targets", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_get_request( + resource_group_name: str, watcher_name: str, target_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/targets/{targetName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + "targetName": _SERIALIZER.url( + "target_name", target_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_create_or_update_request( + resource_group_name: str, watcher_name: str, target_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/targets/{targetName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + "targetName": _SERIALIZER.url( + "target_name", target_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_delete_request( + resource_group_name: str, watcher_name: str, target_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/targets/{targetName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + "targetName": _SERIALIZER.url( + "target_name", target_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) + + +class TargetsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.databasewatcher.MicrosoftDatabaseWatcher`'s + :attr:`targets` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs): + input_args = list(args) + self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: MicrosoftDatabaseWatcherConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def list_by_watcher(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> Iterable["_models.Target"]: + """List Target resources by Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: An iterator like instance of either Target or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.databasewatcher.models.Target] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.TargetListResult] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_list_by_watcher_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request + + def extract_data(pipeline_response): + deserialized = self._deserialize("TargetListResult", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.next_link or None, iter(list_of_elem) + + def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return ItemPaged(get_next, extract_data) + + @distributed_trace + def get(self, resource_group_name: str, watcher_name: str, target_name: str, **kwargs: Any) -> _models.Target: + """Get a Target. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param target_name: The target resource name. Required. + :type target_name: str + :return: Target or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.Target + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.Target] = kwargs.pop("cls", None) + + _request = build_get_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + target_name=target_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("Target", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @overload + def create_or_update( + self, + resource_group_name: str, + watcher_name: str, + target_name: str, + resource: _models.Target, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Target: + """Create a Target. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param target_name: The target resource name. Required. + :type target_name: str + :param resource: Resource create parameters. Required. + :type resource: ~azure.mgmt.databasewatcher.models.Target + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: Target or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.Target + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + resource_group_name: str, + watcher_name: str, + target_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Target: + """Create a Target. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param target_name: The target resource name. Required. + :type target_name: str + :param resource: Resource create parameters. Required. + :type resource: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: Target or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.Target + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + watcher_name: str, + target_name: str, + resource: Union[_models.Target, IO[bytes]], + **kwargs: Any + ) -> _models.Target: + """Create a Target. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param target_name: The target resource name. Required. + :type target_name: str + :param resource: Resource create parameters. Is either a Target type or a IO[bytes] type. + Required. + :type resource: ~azure.mgmt.databasewatcher.models.Target or IO[bytes] + :return: Target or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.Target + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.Target] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(resource, (IOBase, bytes)): + _content = resource + else: + _json = self._serialize.body(resource, "Target") + + _request = build_create_or_update_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + target_name=target_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("Target", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def delete( # pylint: disable=inconsistent-return-statements + self, resource_group_name: str, watcher_name: str, target_name: str, **kwargs: Any + ) -> None: + """Delete a Target. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param target_name: The target resource name. Required. + :type target_name: str + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_delete_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + target_name=target_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 204]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if cls: + return cls(pipeline_response, None, {}) # type: ignore diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_watchers_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_watchers_operations.py new file mode 100644 index 000000000000..33df88b62e6c --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/azure/mgmt/databasewatcher/operations/_watchers_operations.py @@ -0,0 +1,1258 @@ +# pylint: disable=line-too-long,useless-suppression,too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from collections.abc import MutableMapping +from io import IOBase +from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, TypeVar, Union, cast, overload +import urllib.parse + +from azure.core import PipelineClient +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, + map_error, +) +from azure.core.paging import ItemPaged +from azure.core.pipeline import PipelineResponse +from azure.core.polling import LROPoller, NoPolling, PollingMethod +from azure.core.rest import HttpRequest, HttpResponse +from azure.core.tracing.decorator import distributed_trace +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat +from azure.mgmt.core.polling.arm_polling import ARMPolling + +from .. import models as _models +from .._configuration import MicrosoftDatabaseWatcherConfiguration +from .._utils.serialization import Deserializer, Serializer + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_list_by_subscription_request(subscription_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.DatabaseWatcher/watchers") + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_list_by_resource_group_request(resource_group_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_get_request(resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_create_or_update_request( + resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_update_request( + resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_delete_request( + resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_start_request( + resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/start", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_stop_request(resource_group_name: str, watcher_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-01-02")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DatabaseWatcher/watchers/{watcherName}/stop", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "watcherName": _SERIALIZER.url( + "watcher_name", watcher_name, "str", pattern=r"^[a-zA-Z0-9]{1}[a-zA-Z0-9-_]{3,60}$" + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + + +class WatchersOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.databasewatcher.MicrosoftDatabaseWatcher`'s + :attr:`watchers` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs): + input_args = list(args) + self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: MicrosoftDatabaseWatcherConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.Watcher"]: + """List Watcher resources by subscription ID. + + :return: An iterator like instance of either Watcher or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.WatcherListResult] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_list_by_subscription_request( + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request + + def extract_data(pipeline_response): + deserialized = self._deserialize("WatcherListResult", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.next_link or None, iter(list_of_elem) + + def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return ItemPaged(get_next, extract_data) + + @distributed_trace + def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Iterable["_models.Watcher"]: + """List Watcher resources by resource group. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :return: An iterator like instance of either Watcher or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.WatcherListResult] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_list_by_resource_group_request( + resource_group_name=resource_group_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request + + def extract_data(pipeline_response): + deserialized = self._deserialize("WatcherListResult", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.next_link or None, iter(list_of_elem) + + def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return ItemPaged(get_next, extract_data) + + @distributed_trace + def get(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> _models.Watcher: + """Get a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: Watcher or the result of cls(response) + :rtype: ~azure.mgmt.databasewatcher.models.Watcher + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) + + _request = build_get_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("Watcher", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + def _create_or_update_initial( + self, resource_group_name: str, watcher_name: str, resource: Union[_models.Watcher, IO[bytes]], **kwargs: Any + ) -> Iterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(resource, (IOBase, bytes)): + _content = resource + else: + _json = self._serialize.body(resource, "Watcher") + + _request = build_create_or_update_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 201: + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + watcher_name: str, + resource: _models.Watcher, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[_models.Watcher]: + """Create a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param resource: Resource create parameters. Required. + :type resource: ~azure.mgmt.databasewatcher.models.Watcher + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: An instance of LROPoller that returns either Watcher or the result of cls(response) + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + watcher_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[_models.Watcher]: + """Create a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param resource: Resource create parameters. Required. + :type resource: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: An instance of LROPoller that returns either Watcher or the result of cls(response) + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def begin_create_or_update( + self, resource_group_name: str, watcher_name: str, resource: Union[_models.Watcher, IO[bytes]], **kwargs: Any + ) -> LROPoller[_models.Watcher]: + """Create a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param resource: Resource create parameters. Is either a Watcher type or a IO[bytes] type. + Required. + :type resource: ~azure.mgmt.databasewatcher.models.Watcher or IO[bytes] + :return: An instance of LROPoller that returns either Watcher or the result of cls(response) + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = self._create_or_update_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + resource=resource, + api_version=api_version, + content_type=content_type, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): + deserialized = self._deserialize("Watcher", pipeline_response.http_response) + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + return deserialized + + if polling is True: + polling_method: PollingMethod = cast( + PollingMethod, ARMPolling(lro_delay, lro_options={"final-state-via": "azure-async-operation"}, **kwargs) + ) + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling + if cont_token: + return LROPoller[_models.Watcher].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return LROPoller[_models.Watcher]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) + + def _update_initial( + self, + resource_group_name: str, + watcher_name: str, + properties: Union[_models.WatcherUpdate, IO[bytes]], + **kwargs: Any + ) -> Iterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(properties, (IOBase, bytes)): + _content = properties + else: + _json = self._serialize.body(properties, "WatcherUpdate") + + _request = build_update_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 202]: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 202: + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @overload + def begin_update( + self, + resource_group_name: str, + watcher_name: str, + properties: _models.WatcherUpdate, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[_models.Watcher]: + """Update a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param properties: The resource properties to be updated. Required. + :type properties: ~azure.mgmt.databasewatcher.models.WatcherUpdate + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: An instance of LROPoller that returns either Watcher or the result of cls(response) + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def begin_update( + self, + resource_group_name: str, + watcher_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[_models.Watcher]: + """Update a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param properties: The resource properties to be updated. Required. + :type properties: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: An instance of LROPoller that returns either Watcher or the result of cls(response) + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def begin_update( + self, + resource_group_name: str, + watcher_name: str, + properties: Union[_models.WatcherUpdate, IO[bytes]], + **kwargs: Any + ) -> LROPoller[_models.Watcher]: + """Update a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :param properties: The resource properties to be updated. Is either a WatcherUpdate type or a + IO[bytes] type. Required. + :type properties: ~azure.mgmt.databasewatcher.models.WatcherUpdate or IO[bytes] + :return: An instance of LROPoller that returns either Watcher or the result of cls(response) + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = self._update_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + properties=properties, + api_version=api_version, + content_type=content_type, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): + deserialized = self._deserialize("Watcher", pipeline_response.http_response) + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + return deserialized + + if polling is True: + polling_method: PollingMethod = cast( + PollingMethod, ARMPolling(lro_delay, lro_options={"final-state-via": "location"}, **kwargs) + ) + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling + if cont_token: + return LROPoller[_models.Watcher].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return LROPoller[_models.Watcher]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) + + def _delete_initial(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> Iterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) + + _request = build_delete_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202, 204]: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 202: + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def begin_delete(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> LROPoller[None]: + """Delete a Watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: An instance of LROPoller that returns either None or the result of cls(response) + :rtype: ~azure.core.polling.LROPoller[None] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[None] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = self._delete_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + api_version=api_version, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements + if cls: + return cls(pipeline_response, None, {}) # type: ignore + + if polling is True: + polling_method: PollingMethod = cast( + PollingMethod, ARMPolling(lro_delay, lro_options={"final-state-via": "location"}, **kwargs) + ) + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling + if cont_token: + return LROPoller[None].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore + + def _start_initial(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> Iterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) + + _request = build_start_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 202]: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 202: + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def begin_start(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> LROPoller[_models.Watcher]: + """The action to start monitoring all targets configured for a database watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: An instance of LROPoller that returns either Watcher or the result of cls(response) + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = self._start_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + api_version=api_version, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): + deserialized = self._deserialize("Watcher", pipeline_response.http_response) + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + return deserialized + + if polling is True: + polling_method: PollingMethod = cast( + PollingMethod, ARMPolling(lro_delay, lro_options={"final-state-via": "azure-async-operation"}, **kwargs) + ) + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling + if cont_token: + return LROPoller[_models.Watcher].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return LROPoller[_models.Watcher]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) + + def _stop_initial(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> Iterator[bytes]: + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) + + _request = build_stop_request( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _decompress = kwargs.pop("decompress", True) + _stream = True + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 202]: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + response_headers = {} + if response.status_code == 202: + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def begin_stop(self, resource_group_name: str, watcher_name: str, **kwargs: Any) -> LROPoller[_models.Watcher]: + """The action to stop monitoring all targets configured for a database watcher. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param watcher_name: The database watcher name. Required. + :type watcher_name: str + :return: An instance of LROPoller that returns either Watcher or the result of cls(response) + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databasewatcher.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.Watcher] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = self._stop_initial( + resource_group_name=resource_group_name, + watcher_name=watcher_name, + api_version=api_version, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + raw_result.http_response.read() # type: ignore + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): + deserialized = self._deserialize("Watcher", pipeline_response.http_response) + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + return deserialized + + if polling is True: + polling_method: PollingMethod = cast( + PollingMethod, ARMPolling(lro_delay, lro_options={"final-state-via": "azure-async-operation"}, **kwargs) + ) + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling + if cont_token: + return LROPoller[_models.Watcher].from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return LROPoller[_models.Watcher]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_create_or_update_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_create_or_update_maximum_set_gen.py index 426b9e7b0197..3837fdfc76d0 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_create_or_update_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_create_or_update_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="A76F9850-996B-40B3-94D4-C98110A0EEC9", ) response = client.alert_rule_resources.create_or_update( @@ -47,6 +48,6 @@ def main(): print(response) -# x-ms-original-file: 2025-01-02/AlertRuleResources_CreateOrUpdate_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/AlertRuleResources_CreateOrUpdate_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_delete_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_delete_maximum_set_gen.py index 97097da2d848..7e8e5b5cdd2b 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_delete_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_delete_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="A76F9850-996B-40B3-94D4-C98110A0EEC9", ) client.alert_rule_resources.delete( @@ -37,6 +38,6 @@ def main(): ) -# x-ms-original-file: 2025-01-02/AlertRuleResources_Delete_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/AlertRuleResources_Delete_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_get_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_get_maximum_set_gen.py index 5456a5537b84..9ec308b69b08 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_get_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_get_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="A76F9850-996B-40B3-94D4-C98110A0EEC9", ) response = client.alert_rule_resources.get( @@ -38,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: 2025-01-02/AlertRuleResources_Get_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/AlertRuleResources_Get_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_list_by_parent_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_list_by_parent_maximum_set_gen.py index f94bc55c055f..9adf269cb364 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_list_by_parent_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/alert_rule_resources_list_by_parent_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="A76F9850-996B-40B3-94D4-C98110A0EEC9", ) response = client.alert_rule_resources.list_by_parent( @@ -38,6 +39,6 @@ def main(): print(item) -# x-ms-original-file: 2025-01-02/AlertRuleResources_ListByParent_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/AlertRuleResources_ListByParent_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/health_validations_get_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/health_validations_get_maximum_set_gen.py index 9dfe4518db77..f5952f40d063 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/health_validations_get_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/health_validations_get_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="A76F9850-996B-40B3-94D4-C98110A0EEC9", ) response = client.health_validations.get( @@ -38,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: 2025-01-02/HealthValidations_Get_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/HealthValidations_Get_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/health_validations_list_by_parent_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/health_validations_list_by_parent_maximum_set_gen.py index 08348e533c03..4308f1d8bbb6 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/health_validations_list_by_parent_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/health_validations_list_by_parent_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="A76F9850-996B-40B3-94D4-C98110A0EEC9", ) response = client.health_validations.list_by_parent( @@ -38,6 +39,6 @@ def main(): print(item) -# x-ms-original-file: 2025-01-02/HealthValidations_ListByParent_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/HealthValidations_ListByParent_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/health_validations_start_validation_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/health_validations_start_validation_maximum_set_gen.py index fbec6dc49a6e..74ecb4b37666 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/health_validations_start_validation_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/health_validations_start_validation_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="A76F9850-996B-40B3-94D4-C98110A0EEC9", ) response = client.health_validations.begin_start_validation( @@ -38,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: 2025-01-02/HealthValidations_StartValidation_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/HealthValidations_StartValidation_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/operations_list_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/operations_list_maximum_set_gen.py index 6b7bda4fc2f8..577b1c49ab2b 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/operations_list_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/operations_list_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,7 +26,7 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), subscription_id="SUBSCRIPTION_ID", ) @@ -35,6 +36,6 @@ def main(): print(item) -# x-ms-original-file: 2025-01-02/Operations_List_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/Operations_List_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/operations_list_minimum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/operations_list_minimum_set_gen.py index 7332661f5848..bde576c5a026 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/operations_list_minimum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/operations_list_minimum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,7 +26,7 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), subscription_id="SUBSCRIPTION_ID", ) @@ -35,6 +36,6 @@ def main(): print(item) -# x-ms-original-file: 2025-01-02/Operations_List_MinimumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/Operations_List_MinimumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_create_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_create_maximum_set_gen.py index 22a553fca841..6c2062dbf98a 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_create_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_create_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="49e0fbd3-75e8-44e7-96fd-5b64d9ad818d", ) response = client.shared_private_link_resources.begin_create( @@ -47,6 +48,6 @@ def main(): print(response) -# x-ms-original-file: 2025-01-02/SharedPrivateLinkResources_Create_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/SharedPrivateLinkResources_Create_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_delete_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_delete_maximum_set_gen.py index 2a1a954e5ea8..334a4d93d71e 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_delete_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_delete_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="49e0fbd3-75e8-44e7-96fd-5b64d9ad818d", ) client.shared_private_link_resources.begin_delete( @@ -37,6 +38,6 @@ def main(): ).result() -# x-ms-original-file: 2025-01-02/SharedPrivateLinkResources_Delete_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/SharedPrivateLinkResources_Delete_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_get_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_get_maximum_set_gen.py index d52de98b9eec..f9545f9d8d9d 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_get_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_get_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="49e0fbd3-75e8-44e7-96fd-5b64d9ad818d", ) response = client.shared_private_link_resources.get( @@ -38,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: 2025-01-02/SharedPrivateLinkResources_Get_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/SharedPrivateLinkResources_Get_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_list_by_watcher_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_list_by_watcher_maximum_set_gen.py index c6898061e740..e13a5de26153 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_list_by_watcher_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/shared_private_link_resources_list_by_watcher_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="49e0fbd3-75e8-44e7-96fd-5b64d9ad818d", ) response = client.shared_private_link_resources.list_by_watcher( @@ -38,6 +39,6 @@ def main(): print(item) -# x-ms-original-file: 2025-01-02/SharedPrivateLinkResources_ListByWatcher_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/SharedPrivateLinkResources_ListByWatcher_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_create_or_update_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_create_or_update_maximum_set_gen.py index 4ce44e0101c9..f86e5dc2b9b3 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_create_or_update_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_create_or_update_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="49e0fbd3-75e8-44e7-96fd-5b64d9ad818d", ) response = client.targets.create_or_update( @@ -46,6 +47,6 @@ def main(): print(response) -# x-ms-original-file: 2025-01-02/Targets_CreateOrUpdate_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/Targets_CreateOrUpdate_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_delete_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_delete_maximum_set_gen.py index db972749c05d..a74234c1e025 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_delete_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_delete_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="49e0fbd3-75e8-44e7-96fd-5b64d9ad818d", ) client.targets.delete( @@ -37,6 +38,6 @@ def main(): ) -# x-ms-original-file: 2025-01-02/Targets_Delete_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/Targets_Delete_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_get_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_get_maximum_set_gen.py index 9669a309518a..36fb29a527f3 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_get_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_get_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="49e0fbd3-75e8-44e7-96fd-5b64d9ad818d", ) response = client.targets.get( @@ -38,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: 2025-01-02/Targets_Get_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/Targets_Get_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_list_by_watcher_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_list_by_watcher_maximum_set_gen.py index f3db61392664..98ce34614b6a 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_list_by_watcher_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/targets_list_by_watcher_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="49e0fbd3-75e8-44e7-96fd-5b64d9ad818d", ) response = client.targets.list_by_watcher( @@ -38,6 +39,6 @@ def main(): print(item) -# x-ms-original-file: 2025-01-02/Targets_ListByWatcher_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/Targets_ListByWatcher_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_create_or_update_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_create_or_update_maximum_set_gen.py index 47358f2a94ac..32fa0ff2fe1c 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_create_or_update_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_create_or_update_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="A76F9850-996B-40B3-94D4-C98110A0EEC9", ) response = client.watchers.begin_create_or_update( @@ -55,6 +56,6 @@ def main(): print(response) -# x-ms-original-file: 2025-01-02/Watchers_CreateOrUpdate_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/Watchers_CreateOrUpdate_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_delete_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_delete_maximum_set_gen.py index 7d9eb47c7588..fefda5f099fe 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_delete_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_delete_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="A76F9850-996B-40B3-94D4-C98110A0EEC9", ) client.watchers.begin_delete( @@ -36,6 +37,6 @@ def main(): ).result() -# x-ms-original-file: 2025-01-02/Watchers_Delete_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/Watchers_Delete_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_get_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_get_maximum_set_gen.py index 99af906bb949..68cda1047736 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_get_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_get_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="A76F9850-996B-40B3-94D4-C98110A0EEC9", ) response = client.watchers.get( @@ -37,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2025-01-02/Watchers_Get_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/Watchers_Get_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_list_by_resource_group_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_list_by_resource_group_maximum_set_gen.py index 9071142a05b5..5ff68356c475 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_list_by_resource_group_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_list_by_resource_group_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="A76F9850-996B-40B3-94D4-C98110A0EEC9", ) response = client.watchers.list_by_resource_group( @@ -37,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: 2025-01-02/Watchers_ListByResourceGroup_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/Watchers_ListByResourceGroup_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_list_by_subscription_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_list_by_subscription_maximum_set_gen.py index 63fbb28a8993..74fc60af0aa6 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_list_by_subscription_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_list_by_subscription_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="A76F9850-996B-40B3-94D4-C98110A0EEC9", ) response = client.watchers.list_by_subscription() @@ -35,6 +36,6 @@ def main(): print(item) -# x-ms-original-file: 2025-01-02/Watchers_ListBySubscription_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/Watchers_ListBySubscription_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_start_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_start_maximum_set_gen.py index 351dc4c8db5d..ef230433629e 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_start_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_start_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,17 +26,18 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="A76F9850-996B-40B3-94D4-C98110A0EEC9", ) - client.watchers.begin_start( + response = client.watchers.begin_start( resource_group_name="rgWatcher", watcher_name="testWatcher", ).result() + print(response) -# x-ms-original-file: 2025-01-02/Watchers_Start_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/Watchers_Start_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_stop_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_stop_maximum_set_gen.py index 092e84b51c27..d1149e328d84 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_stop_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_stop_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,17 +26,18 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="A76F9850-996B-40B3-94D4-C98110A0EEC9", ) - client.watchers.begin_stop( + response = client.watchers.begin_stop( resource_group_name="rgWatcher", watcher_name="myWatcher", ).result() + print(response) -# x-ms-original-file: 2025-01-02/Watchers_Stop_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/Watchers_Stop_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_update_maximum_set_gen.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_update_maximum_set_gen.py index e2084a0e8309..7900c2079b40 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_update_maximum_set_gen.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_samples/watchers_update_maximum_set_gen.py @@ -1,14 +1,15 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential -from azure.mgmt.databasewatcher import DatabaseWatcherMgmtClient +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher """ # PREREQUISITES @@ -25,9 +26,9 @@ def main(): - client = DatabaseWatcherMgmtClient( + client = MicrosoftDatabaseWatcher( credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", + subscription_id="A76F9850-996B-40B3-94D4-C98110A0EEC9", ) response = client.watchers.begin_update( @@ -53,6 +54,6 @@ def main(): print(response) -# x-ms-original-file: 2025-01-02/Watchers_Update_MaximumSet_Gen.json +# x-ms-original-file: specification/databasewatcher/resource-manager/Microsoft.DatabaseWatcher/stable/2025-01-02/examples/Watchers_Update_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/conftest.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/conftest.py index 990055e86a40..26f9e138cfb3 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/conftest.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/conftest.py @@ -2,7 +2,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. +# Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import os @@ -21,16 +21,22 @@ # For security, please avoid record sensitive identity information in recordings @pytest.fixture(scope="session", autouse=True) def add_sanitizers(test_proxy): - databasewatchermgmt_subscription_id = os.environ.get( + microsoftdatabasewatcher_subscription_id = os.environ.get( "AZURE_SUBSCRIPTION_ID", "00000000-0000-0000-0000-000000000000" ) - databasewatchermgmt_tenant_id = os.environ.get("AZURE_TENANT_ID", "00000000-0000-0000-0000-000000000000") - databasewatchermgmt_client_id = os.environ.get("AZURE_CLIENT_ID", "00000000-0000-0000-0000-000000000000") - databasewatchermgmt_client_secret = os.environ.get("AZURE_CLIENT_SECRET", "00000000-0000-0000-0000-000000000000") - add_general_regex_sanitizer(regex=databasewatchermgmt_subscription_id, value="00000000-0000-0000-0000-000000000000") - add_general_regex_sanitizer(regex=databasewatchermgmt_tenant_id, value="00000000-0000-0000-0000-000000000000") - add_general_regex_sanitizer(regex=databasewatchermgmt_client_id, value="00000000-0000-0000-0000-000000000000") - add_general_regex_sanitizer(regex=databasewatchermgmt_client_secret, value="00000000-0000-0000-0000-000000000000") + microsoftdatabasewatcher_tenant_id = os.environ.get("AZURE_TENANT_ID", "00000000-0000-0000-0000-000000000000") + microsoftdatabasewatcher_client_id = os.environ.get("AZURE_CLIENT_ID", "00000000-0000-0000-0000-000000000000") + microsoftdatabasewatcher_client_secret = os.environ.get( + "AZURE_CLIENT_SECRET", "00000000-0000-0000-0000-000000000000" + ) + add_general_regex_sanitizer( + regex=microsoftdatabasewatcher_subscription_id, value="00000000-0000-0000-0000-000000000000" + ) + add_general_regex_sanitizer(regex=microsoftdatabasewatcher_tenant_id, value="00000000-0000-0000-0000-000000000000") + add_general_regex_sanitizer(regex=microsoftdatabasewatcher_client_id, value="00000000-0000-0000-0000-000000000000") + add_general_regex_sanitizer( + regex=microsoftdatabasewatcher_client_secret, value="00000000-0000-0000-0000-000000000000" + ) add_header_regex_sanitizer(key="Set-Cookie", value="[set-cookie;]") add_header_regex_sanitizer(key="Cookie", value="cookie;") diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_alert_rule_resources_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_alert_rule_resources_operations.py new file mode 100644 index 000000000000..21dc13adc17b --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_alert_rule_resources_operations.py @@ -0,0 +1,89 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestMicrosoftDatabaseWatcherAlertRuleResourcesOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(MicrosoftDatabaseWatcher) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_alert_rule_resources_list_by_parent(self, resource_group): + response = self.client.alert_rule_resources.list_by_parent( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_alert_rule_resources_get(self, resource_group): + response = self.client.alert_rule_resources.get( + resource_group_name=resource_group.name, + watcher_name="str", + alert_rule_resource_name="str", + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_alert_rule_resources_create_or_update(self, resource_group): + response = self.client.alert_rule_resources.create_or_update( + resource_group_name=resource_group.name, + watcher_name="str", + alert_rule_resource_name="str", + resource={ + "alertRuleResourceId": "str", + "alertRuleTemplateId": "str", + "alertRuleTemplateVersion": "str", + "createdWithProperties": "str", + "creationTime": "2020-02-20 00:00:00", + "id": "str", + "name": "str", + "provisioningState": "str", + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "type": "str", + }, + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_alert_rule_resources_delete(self, resource_group): + response = self.client.alert_rule_resources.delete( + resource_group_name=resource_group.name, + watcher_name="str", + alert_rule_resource_name="str", + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_alert_rule_resources_operations_async.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_alert_rule_resources_operations_async.py new file mode 100644 index 000000000000..0b7126261e1e --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_alert_rule_resources_operations_async.py @@ -0,0 +1,90 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.databasewatcher.aio import MicrosoftDatabaseWatcher + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestMicrosoftDatabaseWatcherAlertRuleResourcesOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(MicrosoftDatabaseWatcher, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_alert_rule_resources_list_by_parent(self, resource_group): + response = self.client.alert_rule_resources.list_by_parent( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_alert_rule_resources_get(self, resource_group): + response = await self.client.alert_rule_resources.get( + resource_group_name=resource_group.name, + watcher_name="str", + alert_rule_resource_name="str", + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_alert_rule_resources_create_or_update(self, resource_group): + response = await self.client.alert_rule_resources.create_or_update( + resource_group_name=resource_group.name, + watcher_name="str", + alert_rule_resource_name="str", + resource={ + "alertRuleResourceId": "str", + "alertRuleTemplateId": "str", + "alertRuleTemplateVersion": "str", + "createdWithProperties": "str", + "creationTime": "2020-02-20 00:00:00", + "id": "str", + "name": "str", + "provisioningState": "str", + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "type": "str", + }, + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_alert_rule_resources_delete(self, resource_group): + response = await self.client.alert_rule_resources.delete( + resource_group_name=resource_group.name, + watcher_name="str", + alert_rule_resource_name="str", + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_health_validations_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_health_validations_operations.py new file mode 100644 index 000000000000..d18d22a444c9 --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_health_validations_operations.py @@ -0,0 +1,57 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestMicrosoftDatabaseWatcherHealthValidationsOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(MicrosoftDatabaseWatcher) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_health_validations_list_by_parent(self, resource_group): + response = self.client.health_validations.list_by_parent( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_health_validations_get(self, resource_group): + response = self.client.health_validations.get( + resource_group_name=resource_group.name, + watcher_name="str", + health_validation_name="str", + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_health_validations_begin_start_validation(self, resource_group): + response = self.client.health_validations.begin_start_validation( + resource_group_name=resource_group.name, + watcher_name="str", + health_validation_name="str", + api_version="2025-01-02", + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_health_validations_operations_async.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_health_validations_operations_async.py new file mode 100644 index 000000000000..f6c82d0a1cb4 --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_health_validations_operations_async.py @@ -0,0 +1,60 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.databasewatcher.aio import MicrosoftDatabaseWatcher + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestMicrosoftDatabaseWatcherHealthValidationsOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(MicrosoftDatabaseWatcher, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_health_validations_list_by_parent(self, resource_group): + response = self.client.health_validations.list_by_parent( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_health_validations_get(self, resource_group): + response = await self.client.health_validations.get( + resource_group_name=resource_group.name, + watcher_name="str", + health_validation_name="str", + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_health_validations_begin_start_validation(self, resource_group): + response = await ( + await self.client.health_validations.begin_start_validation( + resource_group_name=resource_group.name, + watcher_name="str", + health_validation_name="str", + api_version="2025-01-02", + ) + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_operations.py new file mode 100644 index 000000000000..a2b5c085f746 --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_operations.py @@ -0,0 +1,29 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestMicrosoftDatabaseWatcherOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(MicrosoftDatabaseWatcher) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_operations_list(self, resource_group): + response = self.client.operations.list( + api_version="2025-01-02", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_operations_async.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_operations_async.py new file mode 100644 index 000000000000..79a69421ae26 --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_operations_async.py @@ -0,0 +1,30 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.databasewatcher.aio import MicrosoftDatabaseWatcher + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestMicrosoftDatabaseWatcherOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(MicrosoftDatabaseWatcher, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_operations_list(self, resource_group): + response = self.client.operations.list( + api_version="2025-01-02", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_shared_private_link_resources_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_shared_private_link_resources_operations.py new file mode 100644 index 000000000000..2b720806f43d --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_shared_private_link_resources_operations.py @@ -0,0 +1,89 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestMicrosoftDatabaseWatcherSharedPrivateLinkResourcesOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(MicrosoftDatabaseWatcher) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_shared_private_link_resources_list_by_watcher(self, resource_group): + response = self.client.shared_private_link_resources.list_by_watcher( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_shared_private_link_resources_get(self, resource_group): + response = self.client.shared_private_link_resources.get( + resource_group_name=resource_group.name, + watcher_name="str", + shared_private_link_resource_name="str", + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_shared_private_link_resources_begin_create(self, resource_group): + response = self.client.shared_private_link_resources.begin_create( + resource_group_name=resource_group.name, + watcher_name="str", + shared_private_link_resource_name="str", + resource={ + "dnsZone": "str", + "groupId": "str", + "id": "str", + "name": "str", + "privateLinkResourceId": "str", + "provisioningState": "str", + "requestMessage": "str", + "status": "str", + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "type": "str", + }, + api_version="2025-01-02", + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_shared_private_link_resources_begin_delete(self, resource_group): + response = self.client.shared_private_link_resources.begin_delete( + resource_group_name=resource_group.name, + watcher_name="str", + shared_private_link_resource_name="str", + api_version="2025-01-02", + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_shared_private_link_resources_operations_async.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_shared_private_link_resources_operations_async.py new file mode 100644 index 000000000000..5bfdbde8e1f0 --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_shared_private_link_resources_operations_async.py @@ -0,0 +1,94 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.databasewatcher.aio import MicrosoftDatabaseWatcher + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestMicrosoftDatabaseWatcherSharedPrivateLinkResourcesOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(MicrosoftDatabaseWatcher, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_shared_private_link_resources_list_by_watcher(self, resource_group): + response = self.client.shared_private_link_resources.list_by_watcher( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_shared_private_link_resources_get(self, resource_group): + response = await self.client.shared_private_link_resources.get( + resource_group_name=resource_group.name, + watcher_name="str", + shared_private_link_resource_name="str", + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_shared_private_link_resources_begin_create(self, resource_group): + response = await ( + await self.client.shared_private_link_resources.begin_create( + resource_group_name=resource_group.name, + watcher_name="str", + shared_private_link_resource_name="str", + resource={ + "dnsZone": "str", + "groupId": "str", + "id": "str", + "name": "str", + "privateLinkResourceId": "str", + "provisioningState": "str", + "requestMessage": "str", + "status": "str", + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "type": "str", + }, + api_version="2025-01-02", + ) + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_shared_private_link_resources_begin_delete(self, resource_group): + response = await ( + await self.client.shared_private_link_resources.begin_delete( + resource_group_name=resource_group.name, + watcher_name="str", + shared_private_link_resource_name="str", + api_version="2025-01-02", + ) + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_targets_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_targets_operations.py new file mode 100644 index 000000000000..aa54533a8ea5 --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_targets_operations.py @@ -0,0 +1,87 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestMicrosoftDatabaseWatcherTargetsOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(MicrosoftDatabaseWatcher) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_targets_list_by_watcher(self, resource_group): + response = self.client.targets.list_by_watcher( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_targets_get(self, resource_group): + response = self.client.targets.get( + resource_group_name=resource_group.name, + watcher_name="str", + target_name="str", + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_targets_create_or_update(self, resource_group): + response = self.client.targets.create_or_update( + resource_group_name=resource_group.name, + watcher_name="str", + target_name="str", + resource={ + "connectionServerName": "str", + "id": "str", + "name": "str", + "provisioningState": "str", + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "targetAuthenticationType": "str", + "targetVault": {"akvResourceId": "str", "akvTargetPassword": "str", "akvTargetUser": "str"}, + "type": "str", + }, + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_targets_delete(self, resource_group): + response = self.client.targets.delete( + resource_group_name=resource_group.name, + watcher_name="str", + target_name="str", + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_targets_operations_async.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_targets_operations_async.py new file mode 100644 index 000000000000..401310689aaf --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_targets_operations_async.py @@ -0,0 +1,88 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.databasewatcher.aio import MicrosoftDatabaseWatcher + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestMicrosoftDatabaseWatcherTargetsOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(MicrosoftDatabaseWatcher, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_targets_list_by_watcher(self, resource_group): + response = self.client.targets.list_by_watcher( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_targets_get(self, resource_group): + response = await self.client.targets.get( + resource_group_name=resource_group.name, + watcher_name="str", + target_name="str", + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_targets_create_or_update(self, resource_group): + response = await self.client.targets.create_or_update( + resource_group_name=resource_group.name, + watcher_name="str", + target_name="str", + resource={ + "connectionServerName": "str", + "id": "str", + "name": "str", + "provisioningState": "str", + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "targetAuthenticationType": "str", + "targetVault": {"akvResourceId": "str", "akvTargetPassword": "str", "akvTargetUser": "str"}, + "type": "str", + }, + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_targets_delete(self, resource_group): + response = await self.client.targets.delete( + resource_group_name=resource_group.name, + watcher_name="str", + target_name="str", + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_watchers_operations.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_watchers_operations.py new file mode 100644 index 000000000000..91a6d9d465da --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_watchers_operations.py @@ -0,0 +1,164 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.databasewatcher import MicrosoftDatabaseWatcher + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestMicrosoftDatabaseWatcherWatchersOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(MicrosoftDatabaseWatcher) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_watchers_list_by_subscription(self, resource_group): + response = self.client.watchers.list_by_subscription( + api_version="2025-01-02", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_watchers_list_by_resource_group(self, resource_group): + response = self.client.watchers.list_by_resource_group( + resource_group_name=resource_group.name, + api_version="2025-01-02", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_watchers_get(self, resource_group): + response = self.client.watchers.get( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_watchers_begin_create_or_update(self, resource_group): + response = self.client.watchers.begin_create_or_update( + resource_group_name=resource_group.name, + watcher_name="str", + resource={ + "location": "str", + "datastore": { + "kustoClusterUri": "str", + "kustoDataIngestionUri": "str", + "kustoDatabaseName": "str", + "kustoManagementUrl": "str", + "kustoOfferingType": "str", + "adxClusterResourceId": "str", + "kustoClusterDisplayName": "str", + }, + "defaultAlertRuleIdentityResourceId": "str", + "id": "str", + "identity": { + "type": "str", + "principalId": "str", + "tenantId": "str", + "userAssignedIdentities": {"str": {"clientId": "str", "principalId": "str"}}, + }, + "name": "str", + "provisioningState": "str", + "status": "str", + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "tags": {"str": "str"}, + "type": "str", + }, + api_version="2025-01-02", + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_watchers_begin_update(self, resource_group): + response = self.client.watchers.begin_update( + resource_group_name=resource_group.name, + watcher_name="str", + properties={ + "datastore": { + "adxClusterResourceId": "str", + "kustoClusterDisplayName": "str", + "kustoClusterUri": "str", + "kustoDataIngestionUri": "str", + "kustoDatabaseName": "str", + "kustoManagementUrl": "str", + "kustoOfferingType": "str", + }, + "defaultAlertRuleIdentityResourceId": "str", + "identity": { + "type": "str", + "principalId": "str", + "tenantId": "str", + "userAssignedIdentities": {"str": {"clientId": "str", "principalId": "str"}}, + }, + "tags": {"str": "str"}, + }, + api_version="2025-01-02", + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_watchers_begin_delete(self, resource_group): + response = self.client.watchers.begin_delete( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_watchers_begin_start(self, resource_group): + response = self.client.watchers.begin_start( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_watchers_begin_stop(self, resource_group): + response = self.client.watchers.begin_stop( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_watchers_operations_async.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_watchers_operations_async.py new file mode 100644 index 000000000000..ed26a098a617 --- /dev/null +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/generated_tests/test_microsoft_database_watcher_watchers_operations_async.py @@ -0,0 +1,175 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.databasewatcher.aio import MicrosoftDatabaseWatcher + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestMicrosoftDatabaseWatcherWatchersOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(MicrosoftDatabaseWatcher, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_watchers_list_by_subscription(self, resource_group): + response = self.client.watchers.list_by_subscription( + api_version="2025-01-02", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_watchers_list_by_resource_group(self, resource_group): + response = self.client.watchers.list_by_resource_group( + resource_group_name=resource_group.name, + api_version="2025-01-02", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_watchers_get(self, resource_group): + response = await self.client.watchers.get( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_watchers_begin_create_or_update(self, resource_group): + response = await ( + await self.client.watchers.begin_create_or_update( + resource_group_name=resource_group.name, + watcher_name="str", + resource={ + "location": "str", + "datastore": { + "kustoClusterUri": "str", + "kustoDataIngestionUri": "str", + "kustoDatabaseName": "str", + "kustoManagementUrl": "str", + "kustoOfferingType": "str", + "adxClusterResourceId": "str", + "kustoClusterDisplayName": "str", + }, + "defaultAlertRuleIdentityResourceId": "str", + "id": "str", + "identity": { + "type": "str", + "principalId": "str", + "tenantId": "str", + "userAssignedIdentities": {"str": {"clientId": "str", "principalId": "str"}}, + }, + "name": "str", + "provisioningState": "str", + "status": "str", + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "tags": {"str": "str"}, + "type": "str", + }, + api_version="2025-01-02", + ) + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_watchers_begin_update(self, resource_group): + response = await ( + await self.client.watchers.begin_update( + resource_group_name=resource_group.name, + watcher_name="str", + properties={ + "datastore": { + "adxClusterResourceId": "str", + "kustoClusterDisplayName": "str", + "kustoClusterUri": "str", + "kustoDataIngestionUri": "str", + "kustoDatabaseName": "str", + "kustoManagementUrl": "str", + "kustoOfferingType": "str", + }, + "defaultAlertRuleIdentityResourceId": "str", + "identity": { + "type": "str", + "principalId": "str", + "tenantId": "str", + "userAssignedIdentities": {"str": {"clientId": "str", "principalId": "str"}}, + }, + "tags": {"str": "str"}, + }, + api_version="2025-01-02", + ) + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_watchers_begin_delete(self, resource_group): + response = await ( + await self.client.watchers.begin_delete( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ) + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_watchers_begin_start(self, resource_group): + response = await ( + await self.client.watchers.begin_start( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ) + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_watchers_begin_stop(self, resource_group): + response = await ( + await self.client.watchers.begin_stop( + resource_group_name=resource_group.name, + watcher_name="str", + api_version="2025-01-02", + ) + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/sdk_packaging.toml b/sdk/databasewatcher/azure-mgmt-databasewatcher/sdk_packaging.toml index 7f7aa6c17541..c4a37028179b 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/sdk_packaging.toml +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/sdk_packaging.toml @@ -3,7 +3,7 @@ package_name = "azure-mgmt-databasewatcher" package_nspkg = "azure-mgmt-nspkg" package_pprint_name = "Databasewatcher Management" package_doc_id = "" -is_stable = false +is_stable = true is_arm = true need_msrestazure = false need_azuremgmtcore = true diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/setup.py b/sdk/databasewatcher/azure-mgmt-databasewatcher/setup.py index c7effaf033fc..4fcfad6fe3a1 100644 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/setup.py +++ b/sdk/databasewatcher/azure-mgmt-databasewatcher/setup.py @@ -49,11 +49,10 @@ url="https://github.com/Azure/azure-sdk-for-python", keywords="azure, azure sdk", # update with search keywords relevant to the azure service / product classifiers=[ - "Development Status :: 4 - Beta", + "Development Status :: 5 - Production/Stable", "Programming Language :: Python", "Programming Language :: Python :: 3 :: Only", "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", @@ -77,7 +76,7 @@ "isodate>=0.6.1", "typing-extensions>=4.6.0", "azure-common>=1.1", - "azure-mgmt-core>=1.3.2", + "azure-mgmt-core>=1.5.0", ], - python_requires=">=3.8", + python_requires=">=3.9", ) diff --git a/sdk/databasewatcher/azure-mgmt-databasewatcher/tsp-location.yaml b/sdk/databasewatcher/azure-mgmt-databasewatcher/tsp-location.yaml deleted file mode 100644 index bcd3f01c6196..000000000000 --- a/sdk/databasewatcher/azure-mgmt-databasewatcher/tsp-location.yaml +++ /dev/null @@ -1,4 +0,0 @@ -directory: specification/databasewatcher/DatabaseWatcher.Management -commit: 07da438f8dc690946b39511467744ed889434de5 -repo: Azure/azure-rest-api-specs -additionalDirectories: