diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/README.md b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/README.md
index 1656574ab19cc..c6664d44b582c 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/README.md
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/README.md
@@ -1,28 +1,61 @@
# Microsoft Azure SDK for Python
This is the Microsoft Azure Alerts Management Client Library.
-This package has been tested with Python 3.7+.
+This package has been tested with Python 3.8+.
For a more complete view of Azure libraries, see the [azure sdk python release](https://aka.ms/azsdk/python/all).
## _Disclaimer_
_Azure SDK Python packages support for Python 2.7 has ended 01 January 2022. For more information and questions, please refer to https://github.com/Azure/azure-sdk-for-python/issues/20691_
-# Usage
+## Getting started
+### Prerequisites
-To learn how to use this package, see the [quickstart guide](https://aka.ms/azsdk/python/mgmt)
-
-For docs and references, see [Python SDK References](https://docs.microsoft.com/python/api/overview/azure/)
-Code samples for this package can be found at [Alerts Management](https://docs.microsoft.com/samples/browse/?languages=python&term=Getting%20started%20-%20Managing&terms=Getting%20started%20-%20Managing) on docs.microsoft.com.
-Additional code samples for different Azure services are available at [Samples Repo](https://aka.ms/azsdk/python/mgmt/samples)
+- Python 3.8+ is required to use this package.
+- [Azure subscription](https://azure.microsoft.com/free/)
+### Install the package
-# Provide Feedback
+```bash
+pip install azure-mgmt-alertsmanagement
+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.
+
+- `AZURE_CLIENT_ID` for Azure client ID.
+- `AZURE_TENANT_ID` for Azure tenant ID.
+- `AZURE_CLIENT_SECRET` for Azure client secret.
+
+In addition, Azure subscription ID can be configured via environment variable `AZURE_SUBSCRIPTION_ID`.
+
+With above configuration, client can be authenticated by following code:
+
+```python
+from azure.identity import DefaultAzureCredential
+from azure.mgmt.alertsmanagement import AlertsManagementClient
+import os
+
+sub_id = os.getenv("AZURE_SUBSCRIPTION_ID")
+client = AlertsManagementClient(credential=DefaultAzureCredential(), subscription_id=sub_id)
+```
+
+## Examples
+
+Code samples for this package can be found at:
+- [Search Alerts Management](https://docs.microsoft.com/samples/browse/?languages=python&term=Getting%20started%20-%20Managing&terms=Getting%20started%20-%20Managing) on docs.microsoft.com
+- [Azure Python Mgmt SDK Samples Repo](https://aka.ms/azsdk/python/mgmt/samples)
+
+
+## Troubleshooting
+
+## Next steps
+
+## Provide Feedback
If you encounter any bugs or have suggestions, please file an issue in the
[Issues](https://github.com/Azure/azure-sdk-for-python/issues)
section of the project.
-
-
-![Impressions](https://azure-sdk-impressions.azurewebsites.net/api/impressions/azure-sdk-for-python%2Fazure-mgmt-alertsmanagement%2FREADME.png)
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/_meta.json b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/_meta.json
index 4acb590471e5d..783da5cbc1820 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/_meta.json
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/_meta.json
@@ -1,11 +1,11 @@
{
- "commit": "e37a57df67daaa82f9c3758fc450bc8655812a08",
+ "commit": "0b105aa1cf3379cc106112d1d1f33276b7e874c1",
"repository_url": "https://github.com/Azure/azure-rest-api-specs",
- "autorest": "3.9.2",
+ "autorest": "3.10.2",
"use": [
- "@autorest/python@6.2.7",
- "@autorest/modelerfour@4.24.3"
+ "@autorest/python@6.26.4",
+ "@autorest/modelerfour@4.27.0"
],
- "autorest_command": "autorest specification/alertsmanagement/resource-manager/readme.md --generate-sample=True --include-x-ms-examples-original-file=True --python --python-sdks-folder=/home/vsts/work/1/azure-sdk-for-python/sdk --use=@autorest/python@6.2.7 --use=@autorest/modelerfour@4.24.3 --version=3.9.2 --version-tolerant=False",
+ "autorest_command": "autorest specification/alertsmanagement/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.26.4 --use=@autorest/modelerfour@4.27.0 --version=3.10.2 --version-tolerant=False",
"readme": "specification/alertsmanagement/resource-manager/readme.md"
}
\ No newline at end of file
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/__init__.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/__init__.py
index 8f236949edfcc..e73c34c5a5265 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/__init__.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/__init__.py
@@ -5,15 +5,21 @@
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
+# pylint: disable=wrong-import-position
-from ._alerts_management_client import AlertsManagementClient
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from ._patch import * # pylint: disable=unused-wildcard-import
+
+from ._alerts_management_client import AlertsManagementClient # type: ignore
from ._version import VERSION
__version__ = VERSION
try:
from ._patch import __all__ as _patch_all
- from ._patch import * # pylint: disable=unused-wildcard-import
+ from ._patch import *
except ImportError:
_patch_all = []
from ._patch import patch_sdk as _patch_sdk
@@ -21,6 +27,6 @@
__all__ = [
"AlertsManagementClient",
]
-__all__.extend([p for p in _patch_all if p not in __all__])
+__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore
_patch_sdk()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_alerts_management_client.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_alerts_management_client.py
index e896dc0a388c6..3a5f273fa22b8 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_alerts_management_client.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_alerts_management_client.py
@@ -8,15 +8,18 @@
from copy import deepcopy
from typing import Any, TYPE_CHECKING
+from typing_extensions import Self
+from azure.core.pipeline import policies
from azure.core.rest import HttpRequest, HttpResponse
from azure.mgmt.core import ARMPipelineClient
+from azure.mgmt.core.policies import ARMAutoResourceProviderRegistrationPolicy
from . import models as _models
from ._configuration import AlertsManagementClientConfiguration
from ._serialization import Deserializer, Serializer
from .operations import (
- AlertProcessingRulesOperations,
+ AlertRuleRecommendationsOperations,
AlertsOperations,
Operations,
PrometheusRuleGroupsOperations,
@@ -24,16 +27,12 @@
)
if TYPE_CHECKING:
- # pylint: disable=unused-import,ungrouped-imports
from azure.core.credentials import TokenCredential
class AlertsManagementClient: # pylint: disable=client-accepts-api-version-keyword
"""AlertsManagement Client.
- :ivar alert_processing_rules: AlertProcessingRulesOperations operations
- :vartype alert_processing_rules:
- azure.mgmt.alertsmanagement.operations.AlertProcessingRulesOperations
:ivar prometheus_rule_groups: PrometheusRuleGroupsOperations operations
:vartype prometheus_rule_groups:
azure.mgmt.alertsmanagement.operations.PrometheusRuleGroupsOperations
@@ -43,6 +42,9 @@ class AlertsManagementClient: # pylint: disable=client-accepts-api-version-keyw
:vartype alerts: azure.mgmt.alertsmanagement.operations.AlertsOperations
:ivar smart_groups: SmartGroupsOperations operations
:vartype smart_groups: azure.mgmt.alertsmanagement.operations.SmartGroupsOperations
+ :ivar alert_rule_recommendations: AlertRuleRecommendationsOperations operations
+ :vartype alert_rule_recommendations:
+ azure.mgmt.alertsmanagement.operations.AlertRuleRecommendationsOperations
: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. Required.
@@ -61,23 +63,41 @@ def __init__(
self._config = AlertsManagementClientConfiguration(
credential=credential, subscription_id=subscription_id, **kwargs
)
- self._client = ARMPipelineClient(base_url=base_url, config=self._config, **kwargs)
+ _policies = kwargs.pop("policies", None)
+ if _policies is None:
+ _policies = [
+ policies.RequestIdPolicy(**kwargs),
+ self._config.headers_policy,
+ self._config.user_agent_policy,
+ self._config.proxy_policy,
+ policies.ContentDecodePolicy(**kwargs),
+ ARMAutoResourceProviderRegistrationPolicy(),
+ self._config.redirect_policy,
+ self._config.retry_policy,
+ self._config.authentication_policy,
+ self._config.custom_hook_policy,
+ self._config.logging_policy,
+ policies.DistributedTracingPolicy(**kwargs),
+ policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None,
+ self._config.http_logging_policy,
+ ]
+ self._client: ARMPipelineClient = ARMPipelineClient(base_url=base_url, policies=_policies, **kwargs)
client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self._serialize.client_side_validation = False
- self.alert_processing_rules = AlertProcessingRulesOperations(
- self._client, self._config, self._serialize, self._deserialize
- )
self.prometheus_rule_groups = PrometheusRuleGroupsOperations(
self._client, self._config, self._serialize, self._deserialize
)
self.operations = Operations(self._client, self._config, self._serialize, self._deserialize)
self.alerts = AlertsOperations(self._client, self._config, self._serialize, self._deserialize)
self.smart_groups = SmartGroupsOperations(self._client, self._config, self._serialize, self._deserialize)
+ self.alert_rule_recommendations = AlertRuleRecommendationsOperations(
+ self._client, self._config, self._serialize, self._deserialize
+ )
- def _send_request(self, request: HttpRequest, **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
@@ -97,14 +117,14 @@ def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse:
request_copy = deepcopy(request)
request_copy.url = self._client.format_url(request_copy.url)
- return self._client.send_request(request_copy, **kwargs)
+ return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore
def close(self) -> None:
self._client.close()
- def __enter__(self) -> "AlertsManagementClient":
+ def __enter__(self) -> Self:
self._client.__enter__()
return self
- def __exit__(self, *exc_details) -> None:
+ def __exit__(self, *exc_details: Any) -> None:
self._client.__exit__(*exc_details)
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_configuration.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_configuration.py
index c5cebde237ea8..98cccbe89e57f 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_configuration.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_configuration.py
@@ -8,18 +8,16 @@
from typing import Any, TYPE_CHECKING
-from azure.core.configuration import Configuration
from azure.core.pipeline import policies
from azure.mgmt.core.policies import ARMChallengeAuthenticationPolicy, ARMHttpLoggingPolicy
from ._version import VERSION
if TYPE_CHECKING:
- # pylint: disable=unused-import,ungrouped-imports
from azure.core.credentials import TokenCredential
-class AlertsManagementClientConfiguration(Configuration): # pylint: disable=too-many-instance-attributes
+class AlertsManagementClientConfiguration: # pylint: disable=too-many-instance-attributes
"""Configuration for AlertsManagementClient.
Note that all parameters used to create this instance are saved as instance
@@ -32,7 +30,6 @@ class AlertsManagementClientConfiguration(Configuration): # pylint: disable=too
"""
def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None:
- super(AlertsManagementClientConfiguration, self).__init__(**kwargs)
if credential is None:
raise ValueError("Parameter 'credential' must not be None.")
if subscription_id is None:
@@ -42,6 +39,7 @@ def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs
self.subscription_id = subscription_id
self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"])
kwargs.setdefault("sdk_moniker", "mgmt-alertsmanagement/{}".format(VERSION))
+ self.polling_interval = kwargs.get("polling_interval", 30)
self._configure(**kwargs)
def _configure(self, **kwargs: Any) -> None:
@@ -50,9 +48,9 @@ def _configure(self, **kwargs: Any) -> None:
self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs)
self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs)
self.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**kwargs)
- self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs)
self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs)
self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs)
+ self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs)
self.authentication_policy = kwargs.get("authentication_policy")
if self.credential and not self.authentication_policy:
self.authentication_policy = ARMChallengeAuthenticationPolicy(
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_serialization.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_serialization.py
index 2c170e28dbca2..ce17d1798ce7b 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_serialization.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_serialization.py
@@ -1,3 +1,4 @@
+# pylint: disable=too-many-lines
# --------------------------------------------------------------------------
#
# Copyright (c) Microsoft Corporation. All rights reserved.
@@ -24,7 +25,6 @@
#
# --------------------------------------------------------------------------
-# pylint: skip-file
# pyright: reportUnnecessaryTypeIgnoreComment=false
from base64 import b64decode, b64encode
@@ -38,7 +38,21 @@
import re
import sys
import codecs
-from typing import Optional, Union, AnyStr, IO, Mapping
+from typing import (
+ Dict,
+ Any,
+ cast,
+ Optional,
+ Union,
+ AnyStr,
+ IO,
+ Mapping,
+ Callable,
+ TypeVar,
+ MutableMapping,
+ Type,
+ List,
+)
try:
from urllib import quote # type: ignore
@@ -48,12 +62,14 @@
import isodate # type: ignore
-from typing import Dict, Any, cast
-
-from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback
+from azure.core.exceptions import DeserializationError, SerializationError
+from azure.core.serialization import NULL as CoreNull
_BOM = codecs.BOM_UTF8.decode(encoding="utf-8")
+ModelType = TypeVar("ModelType", bound="Model")
+JSON = MutableMapping[str, Any]
+
class RawDeserializer:
@@ -74,6 +90,8 @@ def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type:
:param data: Input, could be bytes or stream (will be decoded with UTF8) or text
:type data: str or bytes or IO
:param str content_type: The content type.
+ :return: The deserialized data.
+ :rtype: object
"""
if hasattr(data, "read"):
# Assume a stream
@@ -95,7 +113,7 @@ def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type:
try:
return json.loads(data_as_str)
except ValueError as err:
- raise DeserializationError("JSON is invalid: {}".format(err), err)
+ raise DeserializationError("JSON is invalid: {}".format(err), err) from err
elif "xml" in (content_type or []):
try:
@@ -107,7 +125,7 @@ def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type:
pass
return ET.fromstring(data_as_str) # nosec
- except ET.ParseError:
+ except ET.ParseError as err:
# It might be because the server has an issue, and returned JSON with
# content-type XML....
# So let's try a JSON load, and if it's still broken
@@ -126,7 +144,9 @@ def _json_attemp(data):
# The function hack is because Py2.7 messes up with exception
# context otherwise.
_LOGGER.critical("Wasn't XML not JSON, failing")
- raise_with_traceback(DeserializationError, "XML is invalid")
+ raise DeserializationError("XML is invalid") from err
+ elif content_type.startswith("text/"):
+ return data_as_str
raise DeserializationError("Cannot deserialize content-type: {}".format(content_type))
@classmethod
@@ -136,6 +156,11 @@ def deserialize_from_http_generics(cls, body_bytes: Optional[Union[AnyStr, IO]],
Use bytes and headers to NOT use any requests/aiohttp or whatever
specific implementation.
Headers will tested for "content-type"
+
+ :param bytes body_bytes: The body of the response.
+ :param dict headers: The headers of the response.
+ :returns: The deserialized data.
+ :rtype: object
"""
# Try to use content-type from headers if available
content_type = None
@@ -153,13 +178,6 @@ def deserialize_from_http_generics(cls, body_bytes: Optional[Union[AnyStr, IO]],
return None
-try:
- basestring # type: ignore
- unicode_str = unicode # type: ignore
-except NameError:
- basestring = str
- unicode_str = str
-
_LOGGER = logging.getLogger(__name__)
try:
@@ -172,15 +190,30 @@ class UTC(datetime.tzinfo):
"""Time Zone info for handling UTC"""
def utcoffset(self, dt):
- """UTF offset for UTC is 0."""
+ """UTF offset for UTC is 0.
+
+ :param datetime.datetime dt: The datetime
+ :returns: The offset
+ :rtype: datetime.timedelta
+ """
return datetime.timedelta(0)
def tzname(self, dt):
- """Timestamp representation."""
+ """Timestamp representation.
+
+ :param datetime.datetime dt: The datetime
+ :returns: The timestamp representation
+ :rtype: str
+ """
return "Z"
def dst(self, dt):
- """No daylight saving for UTC."""
+ """No daylight saving for UTC.
+
+ :param datetime.datetime dt: The datetime
+ :returns: The daylight saving time
+ :rtype: datetime.timedelta
+ """
return datetime.timedelta(hours=1)
@@ -194,7 +227,7 @@ class _FixedOffset(datetime.tzinfo): # type: ignore
:param datetime.timedelta offset: offset in timedelta format
"""
- def __init__(self, offset):
+ def __init__(self, offset) -> None:
self.__offset = offset
def utcoffset(self, dt):
@@ -223,24 +256,26 @@ def __getinitargs__(self):
_FLATTEN = re.compile(r"(? None:
+ self.additional_properties: Optional[Dict[str, Any]] = {}
+ for k in kwargs: # pylint: disable=consider-using-dict-items
if k not in self._attribute_map:
_LOGGER.warning("%s is not a known attribute of class %s and will be ignored", k, self.__class__)
elif k in self._validation and self._validation[k].get("readonly", False):
@@ -287,25 +329,35 @@ def __init__(self, **kwargs):
else:
setattr(self, k, kwargs[k])
- def __eq__(self, other):
- """Compare objects by comparing all attributes."""
+ def __eq__(self, other: Any) -> bool:
+ """Compare objects by comparing all attributes.
+
+ :param object other: The object to compare
+ :returns: True if objects are equal
+ :rtype: bool
+ """
if isinstance(other, self.__class__):
return self.__dict__ == other.__dict__
return False
- def __ne__(self, other):
- """Compare objects by comparing all attributes."""
+ def __ne__(self, other: Any) -> bool:
+ """Compare objects by comparing all attributes.
+
+ :param object other: The object to compare
+ :returns: True if objects are not equal
+ :rtype: bool
+ """
return not self.__eq__(other)
- def __str__(self):
+ def __str__(self) -> str:
return str(self.__dict__)
@classmethod
- def enable_additional_properties_sending(cls):
+ def enable_additional_properties_sending(cls) -> None:
cls._attribute_map["additional_properties"] = {"key": "", "type": "{object}"}
@classmethod
- def is_xml_model(cls):
+ def is_xml_model(cls) -> bool:
try:
cls._xml_map # type: ignore
except AttributeError:
@@ -314,7 +366,11 @@ def is_xml_model(cls):
@classmethod
def _create_xml_node(cls):
- """Create XML node."""
+ """Create XML node.
+
+ :returns: The XML node
+ :rtype: xml.etree.ElementTree.Element
+ """
try:
xml_map = cls._xml_map # type: ignore
except AttributeError:
@@ -322,8 +378,8 @@ def _create_xml_node(cls):
return _create_xml_node(xml_map.get("name", cls.__name__), xml_map.get("prefix", None), xml_map.get("ns", None))
- def serialize(self, keep_readonly=False, **kwargs):
- """Return the JSON that would be sent to azure from this model.
+ def serialize(self, keep_readonly: bool = False, **kwargs: Any) -> JSON:
+ """Return the JSON that would be sent to server from this model.
This is an alias to `as_dict(full_restapi_key_transformer, keep_readonly=False)`.
@@ -334,10 +390,17 @@ def serialize(self, keep_readonly=False, **kwargs):
:rtype: dict
"""
serializer = Serializer(self._infer_class_models())
- return serializer._serialize(self, keep_readonly=keep_readonly, **kwargs)
+ return serializer._serialize( # type: ignore # pylint: disable=protected-access
+ self, keep_readonly=keep_readonly, **kwargs
+ )
- def as_dict(self, keep_readonly=True, key_transformer=attribute_transformer, **kwargs):
- """Return a dict that can be JSONify using json.dump.
+ def as_dict(
+ self,
+ keep_readonly: bool = True,
+ key_transformer: Callable[[str, Dict[str, Any], Any], Any] = attribute_transformer,
+ **kwargs: Any
+ ) -> JSON:
+ """Return a dict that can be serialized using json.dump.
Advanced usage might optionally use a callback as parameter:
@@ -363,12 +426,15 @@ def my_key_transformer(key, attr_desc, value):
If you want XML serialization, you can pass the kwargs is_xml=True.
+ :param bool keep_readonly: If you want to serialize the readonly attributes
:param function key_transformer: A key transformer function.
:returns: A dict JSON compatible object
:rtype: dict
"""
serializer = Serializer(self._infer_class_models())
- return serializer._serialize(self, key_transformer=key_transformer, keep_readonly=keep_readonly, **kwargs)
+ return serializer._serialize( # type: ignore # pylint: disable=protected-access
+ self, key_transformer=key_transformer, keep_readonly=keep_readonly, **kwargs
+ )
@classmethod
def _infer_class_models(cls):
@@ -378,25 +444,31 @@ def _infer_class_models(cls):
client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
if cls.__name__ not in client_models:
raise ValueError("Not Autorest generated code")
- except Exception:
+ except Exception: # pylint: disable=broad-exception-caught
# Assume it's not Autorest generated (tests?). Add ourselves as dependencies.
client_models = {cls.__name__: cls}
return client_models
@classmethod
- def deserialize(cls, data, content_type=None):
+ def deserialize(cls: Type[ModelType], data: Any, content_type: Optional[str] = None) -> ModelType:
"""Parse a str using the RestAPI syntax and return a model.
:param str data: A str using RestAPI structure. JSON by default.
:param str content_type: JSON by default, set application/xml if XML.
:returns: An instance of this model
:raises: DeserializationError if something went wrong
+ :rtype: ModelType
"""
deserializer = Deserializer(cls._infer_class_models())
- return deserializer(cls.__name__, data, content_type=content_type)
+ return deserializer(cls.__name__, data, content_type=content_type) # type: ignore
@classmethod
- def from_dict(cls, data, key_extractors=None, content_type=None):
+ def from_dict(
+ cls: Type[ModelType],
+ data: Any,
+ key_extractors: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None,
+ content_type: Optional[str] = None,
+ ) -> ModelType:
"""Parse a dict using given key extractor return a model.
By default consider key
@@ -404,13 +476,15 @@ def from_dict(cls, data, key_extractors=None, content_type=None):
and last_rest_key_case_insensitive_extractor)
:param dict data: A dict using RestAPI structure
+ :param function key_extractors: A key extractor function.
:param str content_type: JSON by default, set application/xml if XML.
:returns: An instance of this model
:raises: DeserializationError if something went wrong
+ :rtype: ModelType
"""
deserializer = Deserializer(cls._infer_class_models())
- deserializer.key_extractors = (
- [
+ deserializer.key_extractors = ( # type: ignore
+ [ # type: ignore
attribute_key_case_insensitive_extractor,
rest_key_case_insensitive_extractor,
last_rest_key_case_insensitive_extractor,
@@ -418,7 +492,7 @@ def from_dict(cls, data, key_extractors=None, content_type=None):
if key_extractors is None
else key_extractors
)
- return deserializer(cls.__name__, data, content_type=content_type)
+ return deserializer(cls.__name__, data, content_type=content_type) # type: ignore
@classmethod
def _flatten_subtype(cls, key, objects):
@@ -426,21 +500,25 @@ def _flatten_subtype(cls, key, objects):
return {}
result = dict(cls._subtype_map[key])
for valuetype in cls._subtype_map[key].values():
- result.update(objects[valuetype]._flatten_subtype(key, objects))
+ result.update(objects[valuetype]._flatten_subtype(key, objects)) # pylint: disable=protected-access
return result
@classmethod
def _classify(cls, response, objects):
"""Check the class _subtype_map for any child classes.
We want to ignore any inherited _subtype_maps.
- Remove the polymorphic key from the initial data.
+
+ :param dict response: The initial data
+ :param dict objects: The class objects
+ :returns: The class to be used
+ :rtype: class
"""
for subtype_key in cls.__dict__.get("_subtype_map", {}).keys():
subtype_value = None
if not isinstance(response, ET.Element):
rest_api_response_key = cls._get_rest_key_parts(subtype_key)[-1]
- subtype_value = response.pop(rest_api_response_key, None) or response.pop(subtype_key, None)
+ subtype_value = response.get(rest_api_response_key, None) or response.get(subtype_key, None)
else:
subtype_value = xml_key_extractor(subtype_key, cls._attribute_map[subtype_key], response)
if subtype_value:
@@ -479,11 +557,13 @@ def _decode_attribute_map_key(key):
inside the received data.
:param str key: A key string from the generated code
+ :returns: The decoded key
+ :rtype: str
"""
return key.replace("\\.", ".")
-class Serializer(object):
+class Serializer(object): # pylint: disable=too-many-public-methods
"""Request object model serializer."""
basic_types = {str: "str", int: "int", bool: "bool", float: "float"}
@@ -518,7 +598,7 @@ class Serializer(object):
"multiple": lambda x, y: x % y != 0,
}
- def __init__(self, classes=None):
+ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None:
self.serialize_type = {
"iso-8601": Serializer.serialize_iso,
"rfc-1123": Serializer.serialize_rfc,
@@ -534,17 +614,20 @@ def __init__(self, classes=None):
"[]": self.serialize_iter,
"{}": self.serialize_dict,
}
- self.dependencies = dict(classes) if classes else {}
+ self.dependencies: Dict[str, type] = dict(classes) if classes else {}
self.key_transformer = full_restapi_key_transformer
self.client_side_validation = True
- def _serialize(self, target_obj, data_type=None, **kwargs):
+ def _serialize( # pylint: disable=too-many-nested-blocks, too-many-branches, too-many-statements, too-many-locals
+ self, target_obj, data_type=None, **kwargs
+ ):
"""Serialize data into a string according to type.
- :param target_obj: The data to be serialized.
+ :param object target_obj: The data to be serialized.
:param str data_type: The type to be serialized from.
:rtype: str, dict
:raises: SerializationError if serialization fails.
+ :returns: The serialized data.
"""
key_transformer = kwargs.get("key_transformer", self.key_transformer)
keep_readonly = kwargs.get("keep_readonly", False)
@@ -570,12 +653,14 @@ def _serialize(self, target_obj, data_type=None, **kwargs):
serialized = {}
if is_xml_model_serialization:
- serialized = target_obj._create_xml_node()
+ serialized = target_obj._create_xml_node() # pylint: disable=protected-access
try:
- attributes = target_obj._attribute_map
+ attributes = target_obj._attribute_map # pylint: disable=protected-access
for attr, attr_desc in attributes.items():
attr_name = attr
- if not keep_readonly and target_obj._validation.get(attr_name, {}).get("readonly", False):
+ if not keep_readonly and target_obj._validation.get( # pylint: disable=protected-access
+ attr_name, {}
+ ).get("readonly", False):
continue
if attr_name == "additional_properties" and attr_desc["key"] == "":
@@ -602,7 +687,7 @@ def _serialize(self, target_obj, data_type=None, **kwargs):
if xml_desc.get("attr", False):
if xml_ns:
ET.register_namespace(xml_prefix, xml_ns)
- xml_name = "{}{}".format(xml_ns, xml_name)
+ xml_name = "{{{}}}{}".format(xml_ns, xml_name)
serialized.set(xml_name, new_attr) # type: ignore
continue
if xml_desc.get("text", False):
@@ -611,7 +696,8 @@ def _serialize(self, target_obj, data_type=None, **kwargs):
if isinstance(new_attr, list):
serialized.extend(new_attr) # type: ignore
elif isinstance(new_attr, ET.Element):
- # If the down XML has no XML/Name, we MUST replace the tag with the local tag. But keeping the namespaces.
+ # If the down XML has no XML/Name,
+ # we MUST replace the tag with the local tag. But keeping the namespaces.
if "name" not in getattr(orig_attr, "_xml_map", {}):
splitted_tag = new_attr.tag.split("}")
if len(splitted_tag) == 2: # Namespace
@@ -622,12 +708,11 @@ def _serialize(self, target_obj, data_type=None, **kwargs):
else: # That's a basic type
# Integrate namespace if necessary
local_node = _create_xml_node(xml_name, xml_prefix, xml_ns)
- local_node.text = unicode_str(new_attr)
+ local_node.text = str(new_attr)
serialized.append(local_node) # type: ignore
else: # JSON
for k in reversed(keys): # type: ignore
- unflattened = {k: new_attr}
- new_attr = unflattened
+ new_attr = {k: new_attr}
_new_attr = new_attr
_serialized = serialized
@@ -636,28 +721,29 @@ def _serialize(self, target_obj, data_type=None, **kwargs):
_serialized.update(_new_attr) # type: ignore
_new_attr = _new_attr[k] # type: ignore
_serialized = _serialized[k]
- except ValueError:
- continue
+ except ValueError as err:
+ if isinstance(err, SerializationError):
+ raise
except (AttributeError, KeyError, TypeError) as err:
msg = "Attribute {} in object {} cannot be serialized.\n{}".format(attr_name, class_name, str(target_obj))
- raise_with_traceback(SerializationError, msg, err)
- else:
- return serialized
+ raise SerializationError(msg) from err
+ return serialized
def body(self, data, data_type, **kwargs):
"""Serialize data intended for a request body.
- :param data: The data to be serialized.
+ :param object data: The data to be serialized.
:param str data_type: The type to be serialized from.
:rtype: dict
:raises: SerializationError if serialization fails.
:raises: ValueError if data is None
+ :returns: The serialized request body
"""
# Just in case this is a dict
- internal_data_type = data_type.strip("[]{}")
- internal_data_type = self.dependencies.get(internal_data_type, None)
+ internal_data_type_str = data_type.strip("[]{}")
+ internal_data_type = self.dependencies.get(internal_data_type_str, None)
try:
is_xml_model_serialization = kwargs["is_xml"]
except KeyError:
@@ -681,18 +767,20 @@ def body(self, data, data_type, **kwargs):
attribute_key_case_insensitive_extractor,
last_rest_key_case_insensitive_extractor,
]
- data = deserializer._deserialize(data_type, data)
+ data = deserializer._deserialize(data_type, data) # pylint: disable=protected-access
except DeserializationError as err:
- raise_with_traceback(SerializationError, "Unable to build a model: " + str(err), err)
+ raise SerializationError("Unable to build a model: " + str(err)) from err
return self._serialize(data, data_type, **kwargs)
def url(self, name, data, data_type, **kwargs):
"""Serialize data intended for a URL path.
- :param data: The data to be serialized.
+ :param str name: The name of the URL path parameter.
+ :param object data: The data to be serialized.
:param str data_type: The type to be serialized from.
:rtype: str
+ :returns: The serialized URL path
:raises: TypeError if serialization fails.
:raises: ValueError if data is None
"""
@@ -703,30 +791,30 @@ def url(self, name, data, data_type, **kwargs):
if kwargs.get("skip_quote") is True:
output = str(output)
+ output = output.replace("{", quote("{")).replace("}", quote("}"))
else:
output = quote(str(output), safe="")
- except SerializationError:
- raise TypeError("{} must be type {}.".format(name, data_type))
- else:
- return output
+ except SerializationError as exc:
+ raise TypeError("{} must be type {}.".format(name, data_type)) from exc
+ return output
def query(self, name, data, data_type, **kwargs):
"""Serialize data intended for a URL query.
- :param data: The data to be serialized.
+ :param str name: The name of the query parameter.
+ :param object data: The data to be serialized.
:param str data_type: The type to be serialized from.
- :rtype: str
+ :rtype: str, list
:raises: TypeError if serialization fails.
:raises: ValueError if data is None
+ :returns: The serialized query parameter
"""
try:
# Treat the list aside, since we don't want to encode the div separator
if data_type.startswith("["):
internal_data_type = data_type[1:-1]
- data = [self.serialize_data(d, internal_data_type, **kwargs) if d is not None else "" for d in data]
- if not kwargs.get("skip_quote", False):
- data = [quote(str(d), safe="") for d in data]
- return str(self.serialize_iter(data, internal_data_type, **kwargs))
+ do_quote = not kwargs.get("skip_quote", False)
+ return self.serialize_iter(data, internal_data_type, do_quote=do_quote, **kwargs)
# Not a list, regular serialization
output = self.serialize_data(data, data_type, **kwargs)
@@ -736,19 +824,20 @@ def query(self, name, data, data_type, **kwargs):
output = str(output)
else:
output = quote(str(output), safe="")
- except SerializationError:
- raise TypeError("{} must be type {}.".format(name, data_type))
- else:
- return str(output)
+ except SerializationError as exc:
+ raise TypeError("{} must be type {}.".format(name, data_type)) from exc
+ return str(output)
def header(self, name, data, data_type, **kwargs):
"""Serialize data intended for a request header.
- :param data: The data to be serialized.
+ :param str name: The name of the header.
+ :param object data: The data to be serialized.
:param str data_type: The type to be serialized from.
:rtype: str
:raises: TypeError if serialization fails.
:raises: ValueError if data is None
+ :returns: The serialized header
"""
try:
if data_type in ["[str]"]:
@@ -757,30 +846,31 @@ def header(self, name, data, data_type, **kwargs):
output = self.serialize_data(data, data_type, **kwargs)
if data_type == "bool":
output = json.dumps(output)
- except SerializationError:
- raise TypeError("{} must be type {}.".format(name, data_type))
- else:
- return str(output)
+ except SerializationError as exc:
+ raise TypeError("{} must be type {}.".format(name, data_type)) from exc
+ return str(output)
def serialize_data(self, data, data_type, **kwargs):
"""Serialize generic data according to supplied data type.
- :param data: The data to be serialized.
+ :param object data: The data to be serialized.
:param str data_type: The type to be serialized from.
- :param bool required: Whether it's essential that the data not be
- empty or None
:raises: AttributeError if required data is None.
:raises: ValueError if data is None
:raises: SerializationError if serialization fails.
+ :returns: The serialized data.
+ :rtype: str, int, float, bool, dict, list
"""
if data is None:
raise ValueError("No value for given attribute")
try:
+ if data is CoreNull:
+ return None
if data_type in self.basic_types.values():
return self.serialize_basic(data, data_type, **kwargs)
- elif data_type in self.serialize_type:
+ if data_type in self.serialize_type:
return self.serialize_type[data_type](data, **kwargs)
# If dependencies is empty, try with current data class
@@ -795,12 +885,11 @@ def serialize_data(self, data, data_type, **kwargs):
except (ValueError, TypeError) as err:
msg = "Unable to serialize value: {!r} as type: {!r}."
- raise_with_traceback(SerializationError, msg.format(data, data_type), err)
- else:
- return self._serialize(data, **kwargs)
+ raise SerializationError(msg.format(data, data_type)) from err
+ return self._serialize(data, **kwargs)
@classmethod
- def _get_custom_serializers(cls, data_type, **kwargs):
+ def _get_custom_serializers(cls, data_type, **kwargs): # pylint: disable=inconsistent-return-statements
custom_serializer = kwargs.get("basic_types_serializers", {}).get(data_type)
if custom_serializer:
return custom_serializer
@@ -816,23 +905,26 @@ def serialize_basic(cls, data, data_type, **kwargs):
- basic_types_serializers dict[str, callable] : If set, use the callable as serializer
- is_xml bool : If set, use xml_basic_types_serializers
- :param data: Object to be serialized.
+ :param obj data: Object to be serialized.
:param str data_type: Type of object in the iterable.
+ :rtype: str, int, float, bool
+ :return: serialized object
"""
custom_serializer = cls._get_custom_serializers(data_type, **kwargs)
if custom_serializer:
return custom_serializer(data)
if data_type == "str":
return cls.serialize_unicode(data)
- return eval(data_type)(data) # nosec
+ return eval(data_type)(data) # nosec # pylint: disable=eval-used
@classmethod
def serialize_unicode(cls, data):
"""Special handling for serializing unicode strings in Py2.
Encode to UTF-8 if unicode, otherwise handle as a str.
- :param data: Object to be serialized.
+ :param str data: Object to be serialized.
:rtype: str
+ :return: serialized object
"""
try: # If I received an enum, return its value
return data.value
@@ -846,8 +938,7 @@ def serialize_unicode(cls, data):
return data
except NameError:
return str(data)
- else:
- return str(data)
+ return str(data)
def serialize_iter(self, data, iter_type, div=None, **kwargs):
"""Serialize iterable.
@@ -857,13 +948,13 @@ def serialize_iter(self, data, iter_type, div=None, **kwargs):
serialization_ctxt['type'] should be same as data_type.
- is_xml bool : If set, serialize as XML
- :param list attr: Object to be serialized.
+ :param list data: Object to be serialized.
:param str iter_type: Type of object in the iterable.
- :param bool required: Whether the objects in the iterable must
- not be None or empty.
:param str div: If set, this str will be used to combine the elements
in the iterable into a combined string. Default is 'None'.
+ Defaults to False.
:rtype: list, str
+ :return: serialized iterable
"""
if isinstance(data, str):
raise SerializationError("Refuse str type as a valid iter type.")
@@ -875,9 +966,14 @@ def serialize_iter(self, data, iter_type, div=None, **kwargs):
for d in data:
try:
serialized.append(self.serialize_data(d, iter_type, **kwargs))
- except ValueError:
+ except ValueError as err:
+ if isinstance(err, SerializationError):
+ raise
serialized.append(None)
+ if kwargs.get("do_quote", False):
+ serialized = ["" if s is None else quote(str(s), safe="") for s in serialized]
+
if div:
serialized = ["" if s is None else str(s) for s in serialized]
serialized = div.join(serialized)
@@ -913,16 +1009,17 @@ def serialize_dict(self, attr, dict_type, **kwargs):
:param dict attr: Object to be serialized.
:param str dict_type: Type of object in the dictionary.
- :param bool required: Whether the objects in the dictionary must
- not be None or empty.
:rtype: dict
+ :return: serialized dictionary
"""
serialization_ctxt = kwargs.get("serialization_ctxt", {})
serialized = {}
for key, value in attr.items():
try:
serialized[self.serialize_unicode(key)] = self.serialize_data(value, dict_type, **kwargs)
- except ValueError:
+ except ValueError as err:
+ if isinstance(err, SerializationError):
+ raise
serialized[self.serialize_unicode(key)] = None
if "xml" in serialization_ctxt:
@@ -937,7 +1034,7 @@ def serialize_dict(self, attr, dict_type, **kwargs):
return serialized
- def serialize_object(self, attr, **kwargs):
+ def serialize_object(self, attr, **kwargs): # pylint: disable=too-many-return-statements
"""Serialize a generic object.
This will be handled as a dictionary. If object passed in is not
a basic type (str, int, float, dict, list) it will simply be
@@ -945,6 +1042,7 @@ def serialize_object(self, attr, **kwargs):
:param dict attr: Object to be serialized.
:rtype: dict or str
+ :return: serialized object
"""
if attr is None:
return None
@@ -955,7 +1053,7 @@ def serialize_object(self, attr, **kwargs):
return self.serialize_basic(attr, self.basic_types[obj_type], **kwargs)
if obj_type is _long_type:
return self.serialize_long(attr)
- if obj_type is unicode_str:
+ if obj_type is str:
return self.serialize_unicode(attr)
if obj_type is datetime.datetime:
return self.serialize_iso(attr)
@@ -969,7 +1067,7 @@ def serialize_object(self, attr, **kwargs):
return self.serialize_decimal(attr)
# If it's a model or I know this dependency, serialize as a Model
- elif obj_type in self.dependencies.values() or isinstance(attr, Model):
+ if obj_type in self.dependencies.values() or isinstance(attr, Model):
return self._serialize(attr)
if obj_type == dict:
@@ -1000,56 +1098,61 @@ def serialize_enum(attr, enum_obj=None):
try:
enum_obj(result) # type: ignore
return result
- except ValueError:
+ except ValueError as exc:
for enum_value in enum_obj: # type: ignore
if enum_value.value.lower() == str(attr).lower():
return enum_value.value
error = "{!r} is not valid value for enum {!r}"
- raise SerializationError(error.format(attr, enum_obj))
+ raise SerializationError(error.format(attr, enum_obj)) from exc
@staticmethod
- def serialize_bytearray(attr, **kwargs):
+ def serialize_bytearray(attr, **kwargs): # pylint: disable=unused-argument
"""Serialize bytearray into base-64 string.
- :param attr: Object to be serialized.
+ :param str attr: Object to be serialized.
:rtype: str
+ :return: serialized base64
"""
return b64encode(attr).decode()
@staticmethod
- def serialize_base64(attr, **kwargs):
+ def serialize_base64(attr, **kwargs): # pylint: disable=unused-argument
"""Serialize str into base-64 string.
- :param attr: Object to be serialized.
+ :param str attr: Object to be serialized.
:rtype: str
+ :return: serialized base64
"""
encoded = b64encode(attr).decode("ascii")
return encoded.strip("=").replace("+", "-").replace("/", "_")
@staticmethod
- def serialize_decimal(attr, **kwargs):
+ def serialize_decimal(attr, **kwargs): # pylint: disable=unused-argument
"""Serialize Decimal object to float.
- :param attr: Object to be serialized.
+ :param decimal attr: Object to be serialized.
:rtype: float
+ :return: serialized decimal
"""
return float(attr)
@staticmethod
- def serialize_long(attr, **kwargs):
+ def serialize_long(attr, **kwargs): # pylint: disable=unused-argument
"""Serialize long (Py2) or int (Py3).
- :param attr: Object to be serialized.
+ :param int attr: Object to be serialized.
:rtype: int/long
+ :return: serialized long
"""
return _long_type(attr)
@staticmethod
- def serialize_date(attr, **kwargs):
+ def serialize_date(attr, **kwargs): # pylint: disable=unused-argument
"""Serialize Date object into ISO-8601 formatted string.
:param Date attr: Object to be serialized.
:rtype: str
+ :return: serialized date
"""
if isinstance(attr, str):
attr = isodate.parse_date(attr)
@@ -1057,11 +1160,12 @@ def serialize_date(attr, **kwargs):
return t
@staticmethod
- def serialize_time(attr, **kwargs):
+ def serialize_time(attr, **kwargs): # pylint: disable=unused-argument
"""Serialize Time object into ISO-8601 formatted string.
:param datetime.time attr: Object to be serialized.
:rtype: str
+ :return: serialized time
"""
if isinstance(attr, str):
attr = isodate.parse_time(attr)
@@ -1071,30 +1175,32 @@ def serialize_time(attr, **kwargs):
return t
@staticmethod
- def serialize_duration(attr, **kwargs):
+ def serialize_duration(attr, **kwargs): # pylint: disable=unused-argument
"""Serialize TimeDelta object into ISO-8601 formatted string.
:param TimeDelta attr: Object to be serialized.
:rtype: str
+ :return: serialized duration
"""
if isinstance(attr, str):
attr = isodate.parse_duration(attr)
return isodate.duration_isoformat(attr)
@staticmethod
- def serialize_rfc(attr, **kwargs):
+ def serialize_rfc(attr, **kwargs): # pylint: disable=unused-argument
"""Serialize Datetime object into RFC-1123 formatted string.
:param Datetime attr: Object to be serialized.
:rtype: str
:raises: TypeError if format invalid.
+ :return: serialized rfc
"""
try:
if not attr.tzinfo:
_LOGGER.warning("Datetime with no tzinfo will be considered UTC.")
utc = attr.utctimetuple()
- except AttributeError:
- raise TypeError("RFC1123 object must be valid Datetime object.")
+ except AttributeError as exc:
+ raise TypeError("RFC1123 object must be valid Datetime object.") from exc
return "{}, {:02} {} {:04} {:02}:{:02}:{:02} GMT".format(
Serializer.days[utc.tm_wday],
@@ -1107,12 +1213,13 @@ def serialize_rfc(attr, **kwargs):
)
@staticmethod
- def serialize_iso(attr, **kwargs):
+ def serialize_iso(attr, **kwargs): # pylint: disable=unused-argument
"""Serialize Datetime object into ISO-8601 formatted string.
:param Datetime attr: Object to be serialized.
:rtype: str
:raises: SerializationError if format invalid.
+ :return: serialized iso
"""
if isinstance(attr, str):
attr = isodate.parse_datetime(attr)
@@ -1132,19 +1239,20 @@ def serialize_iso(attr, **kwargs):
return date + microseconds + "Z"
except (ValueError, OverflowError) as err:
msg = "Unable to serialize datetime object."
- raise_with_traceback(SerializationError, msg, err)
+ raise SerializationError(msg) from err
except AttributeError as err:
msg = "ISO-8601 object must be valid Datetime object."
- raise_with_traceback(TypeError, msg, err)
+ raise TypeError(msg) from err
@staticmethod
- def serialize_unix(attr, **kwargs):
+ def serialize_unix(attr, **kwargs): # pylint: disable=unused-argument
"""Serialize Datetime object into IntTime format.
This is represented as seconds.
:param Datetime attr: Object to be serialized.
:rtype: int
:raises: SerializationError if format invalid
+ :return: serialied unix
"""
if isinstance(attr, int):
return attr
@@ -1152,16 +1260,17 @@ def serialize_unix(attr, **kwargs):
if not attr.tzinfo:
_LOGGER.warning("Datetime with no tzinfo will be considered UTC.")
return int(calendar.timegm(attr.utctimetuple()))
- except AttributeError:
- raise TypeError("Unix time object must be valid Datetime object.")
+ except AttributeError as exc:
+ raise TypeError("Unix time object must be valid Datetime object.") from exc
-def rest_key_extractor(attr, attr_desc, data):
+def rest_key_extractor(attr, attr_desc, data): # pylint: disable=unused-argument
key = attr_desc["key"]
working_data = data
while "." in key:
- dict_keys = _FLATTEN.split(key)
+ # Need the cast, as for some reasons "split" is typed as list[str | Any]
+ dict_keys = cast(List[str], _FLATTEN.split(key))
if len(dict_keys) == 1:
key = _decode_attribute_map_key(dict_keys[0])
break
@@ -1170,14 +1279,15 @@ def rest_key_extractor(attr, attr_desc, data):
if working_data is None:
# If at any point while following flatten JSON path see None, it means
# that all properties under are None as well
- # https://github.com/Azure/msrest-for-python/issues/197
return None
key = ".".join(dict_keys[1:])
return working_data.get(key)
-def rest_key_case_insensitive_extractor(attr, attr_desc, data):
+def rest_key_case_insensitive_extractor( # pylint: disable=unused-argument, inconsistent-return-statements
+ attr, attr_desc, data
+):
key = attr_desc["key"]
working_data = data
@@ -1191,7 +1301,6 @@ def rest_key_case_insensitive_extractor(attr, attr_desc, data):
if working_data is None:
# If at any point while following flatten JSON path see None, it means
# that all properties under are None as well
- # https://github.com/Azure/msrest-for-python/issues/197
return None
key = ".".join(dict_keys[1:])
@@ -1199,17 +1308,29 @@ def rest_key_case_insensitive_extractor(attr, attr_desc, data):
return attribute_key_case_insensitive_extractor(key, None, working_data)
-def last_rest_key_extractor(attr, attr_desc, data):
- """Extract the attribute in "data" based on the last part of the JSON path key."""
+def last_rest_key_extractor(attr, attr_desc, data): # pylint: disable=unused-argument
+ """Extract the attribute in "data" based on the last part of the JSON path key.
+
+ :param str attr: The attribute to extract
+ :param dict attr_desc: The attribute description
+ :param dict data: The data to extract from
+ :rtype: object
+ :returns: The extracted attribute
+ """
key = attr_desc["key"]
dict_keys = _FLATTEN.split(key)
return attribute_key_extractor(dict_keys[-1], None, data)
-def last_rest_key_case_insensitive_extractor(attr, attr_desc, data):
+def last_rest_key_case_insensitive_extractor(attr, attr_desc, data): # pylint: disable=unused-argument
"""Extract the attribute in "data" based on the last part of the JSON path key.
This is the case insensitive version of "last_rest_key_extractor"
+ :param str attr: The attribute to extract
+ :param dict attr_desc: The attribute description
+ :param dict data: The data to extract from
+ :rtype: object
+ :returns: The extracted attribute
"""
key = attr_desc["key"]
dict_keys = _FLATTEN.split(key)
@@ -1242,11 +1363,11 @@ def _extract_name_from_internal_type(internal_type):
xml_name = internal_type_xml_map.get("name", internal_type.__name__)
xml_ns = internal_type_xml_map.get("ns", None)
if xml_ns:
- xml_name = "{}{}".format(xml_ns, xml_name)
+ xml_name = "{{{}}}{}".format(xml_ns, xml_name)
return xml_name
-def xml_key_extractor(attr, attr_desc, data):
+def xml_key_extractor(attr, attr_desc, data): # pylint: disable=unused-argument,too-many-return-statements
if isinstance(data, dict):
return None
@@ -1266,7 +1387,7 @@ def xml_key_extractor(attr, attr_desc, data):
# Integrate namespace if necessary
xml_ns = xml_desc.get("ns", internal_type_xml_map.get("ns", None))
if xml_ns:
- xml_name = "{}{}".format(xml_ns, xml_name)
+ xml_name = "{{{}}}{}".format(xml_ns, xml_name)
# If it's an attribute, that's simple
if xml_desc.get("attr", False):
@@ -1298,22 +1419,21 @@ def xml_key_extractor(attr, attr_desc, data):
if is_iter_type:
if is_wrapped:
return None # is_wrapped no node, we want None
- else:
- return [] # not wrapped, assume empty list
+ return [] # not wrapped, assume empty list
return None # Assume it's not there, maybe an optional node.
# If is_iter_type and not wrapped, return all found children
if is_iter_type:
if not is_wrapped:
return children
- else: # Iter and wrapped, should have found one node only (the wrap one)
- if len(children) != 1:
- raise DeserializationError(
- "Tried to deserialize an array not wrapped, and found several nodes '{}'. Maybe you should declare this array as wrapped?".format(
- xml_name
- )
+ # Iter and wrapped, should have found one node only (the wrap one)
+ if len(children) != 1:
+ raise DeserializationError(
+ "Tried to deserialize an array not wrapped, and found several nodes '{}'. Maybe you should declare this array as wrapped?".format( # pylint: disable=line-too-long
+ xml_name
)
- return list(children[0]) # Might be empty list and that's ok.
+ )
+ return list(children[0]) # Might be empty list and that's ok.
# Here it's not a itertype, we should have found one element only or empty
if len(children) > 1:
@@ -1330,9 +1450,9 @@ class Deserializer(object):
basic_types = {str: "str", int: "int", bool: "bool", float: "float"}
- valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?")
+ valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?")
- def __init__(self, classes=None):
+ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None:
self.deserialize_type = {
"iso-8601": Deserializer.deserialize_iso,
"rfc-1123": Deserializer.deserialize_rfc,
@@ -1352,7 +1472,7 @@ def __init__(self, classes=None):
"duration": (isodate.Duration, datetime.timedelta),
"iso-8601": (datetime.datetime),
}
- self.dependencies = dict(classes) if classes else {}
+ self.dependencies: Dict[str, type] = dict(classes) if classes else {}
self.key_extractors = [rest_key_extractor, xml_key_extractor]
# Additional properties only works if the "rest_key_extractor" is used to
# extract the keys. Making it to work whatever the key extractor is too much
@@ -1370,11 +1490,12 @@ def __call__(self, target_obj, response_data, content_type=None):
:param str content_type: Swagger "produces" if available.
:raises: DeserializationError if deserialization fails.
:return: Deserialized object.
+ :rtype: object
"""
data = self._unpack_content(response_data, content_type)
return self._deserialize(target_obj, data)
- def _deserialize(self, target_obj, data):
+ def _deserialize(self, target_obj, data): # pylint: disable=inconsistent-return-statements
"""Call the deserializer on a model.
Data needs to be already deserialized as JSON or XML ElementTree
@@ -1383,12 +1504,13 @@ def _deserialize(self, target_obj, data):
:param object data: Object to deserialize.
:raises: DeserializationError if deserialization fails.
:return: Deserialized object.
+ :rtype: object
"""
# This is already a model, go recursive just in case
if hasattr(data, "_attribute_map"):
constants = [name for name, config in getattr(data, "_validation", {}).items() if config.get("constant")]
try:
- for attr, mapconfig in data._attribute_map.items():
+ for attr, mapconfig in data._attribute_map.items(): # pylint: disable=protected-access
if attr in constants:
continue
value = getattr(data, attr)
@@ -1405,15 +1527,15 @@ def _deserialize(self, target_obj, data):
response, class_name = self._classify_target(target_obj, data)
- if isinstance(response, basestring):
+ if isinstance(response, str):
return self.deserialize_data(data, response)
- elif isinstance(response, type) and issubclass(response, Enum):
+ if isinstance(response, type) and issubclass(response, Enum):
return self.deserialize_enum(data, response)
- if data is None:
+ if data is None or data is CoreNull:
return data
try:
- attributes = response._attribute_map # type: ignore
+ attributes = response._attribute_map # type: ignore # pylint: disable=protected-access
d_attrs = {}
for attr, attr_desc in attributes.items():
# Check empty string. If it's not empty, someone has a real "additionalProperties"...
@@ -1442,10 +1564,9 @@ def _deserialize(self, target_obj, data):
d_attrs[attr] = value
except (AttributeError, TypeError, KeyError) as err:
msg = "Unable to deserialize to object: " + class_name # type: ignore
- raise_with_traceback(DeserializationError, msg, err)
- else:
- additional_properties = self._build_additional_properties(attributes, data)
- return self._instantiate_model(response, d_attrs, additional_properties)
+ raise DeserializationError(msg) from err
+ additional_properties = self._build_additional_properties(attributes, data)
+ return self._instantiate_model(response, d_attrs, additional_properties)
def _build_additional_properties(self, attribute_map, data):
if not self.additional_properties_detection:
@@ -1471,22 +1592,24 @@ def _classify_target(self, target, data):
Once classification has been determined, initialize object.
:param str target: The target object type to deserialize to.
- :param str/dict data: The response data to deseralize.
+ :param str/dict data: The response data to deserialize.
+ :return: The classified target object and its class name.
+ :rtype: tuple
"""
if target is None:
return None, None
- if isinstance(target, basestring):
+ if isinstance(target, str):
try:
target = self.dependencies[target]
except KeyError:
return target, target
try:
- target = target._classify(data, self.dependencies)
+ target = target._classify(data, self.dependencies) # type: ignore # pylint: disable=protected-access
except AttributeError:
pass # Target is not a Model, no classify
- return target, target.__class__.__name__
+ return target, target.__class__.__name__ # type: ignore
def failsafe_deserialize(self, target_obj, data, content_type=None):
"""Ignores any errors encountered in deserialization,
@@ -1496,12 +1619,14 @@ def failsafe_deserialize(self, target_obj, data, content_type=None):
a deserialization error.
:param str target_obj: The target object type to deserialize to.
- :param str/dict data: The response data to deseralize.
+ :param str/dict data: The response data to deserialize.
:param str content_type: Swagger "produces" if available.
+ :return: Deserialized object.
+ :rtype: object
"""
try:
return self(target_obj, data, content_type=content_type)
- except:
+ except: # pylint: disable=bare-except
_LOGGER.debug(
"Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True
)
@@ -1519,10 +1644,12 @@ def _unpack_content(raw_data, content_type=None):
If raw_data is something else, bypass all logic and return it directly.
- :param raw_data: Data to be processed.
- :param content_type: How to parse if raw_data is a string/bytes.
+ :param obj raw_data: Data to be processed.
+ :param str content_type: How to parse if raw_data is a string/bytes.
:raises JSONDecodeError: If JSON is requested and parsing is impossible.
:raises UnicodeDecodeError: If bytes is not UTF8
+ :rtype: object
+ :return: Unpacked content.
"""
# Assume this is enough to detect a Pipeline Response without importing it
context = getattr(raw_data, "context", {})
@@ -1539,21 +1666,28 @@ def _unpack_content(raw_data, content_type=None):
if hasattr(raw_data, "_content_consumed"):
return RawDeserializer.deserialize_from_http_generics(raw_data.text, raw_data.headers)
- if isinstance(raw_data, (basestring, bytes)) or hasattr(raw_data, "read"):
+ if isinstance(raw_data, (str, bytes)) or hasattr(raw_data, "read"):
return RawDeserializer.deserialize_from_text(raw_data, content_type) # type: ignore
return raw_data
def _instantiate_model(self, response, attrs, additional_properties=None):
"""Instantiate a response model passing in deserialized args.
- :param response: The response model class.
- :param d_attrs: The deserialized response attributes.
+ :param Response response: The response model class.
+ :param dict attrs: The deserialized response attributes.
+ :param dict additional_properties: Additional properties to be set.
+ :rtype: Response
+ :return: The instantiated response model.
"""
if callable(response):
subtype = getattr(response, "_subtype_map", {})
try:
- readonly = [k for k, v in response._validation.items() if v.get("readonly")]
- const = [k for k, v in response._validation.items() if v.get("constant")]
+ readonly = [
+ k for k, v in response._validation.items() if v.get("readonly") # pylint: disable=protected-access
+ ]
+ const = [
+ k for k, v in response._validation.items() if v.get("constant") # pylint: disable=protected-access
+ ]
kwargs = {k: v for k, v in attrs.items() if k not in subtype and k not in readonly + const}
response_obj = response(**kwargs)
for attr in readonly:
@@ -1563,7 +1697,7 @@ def _instantiate_model(self, response, attrs, additional_properties=None):
return response_obj
except TypeError as err:
msg = "Unable to deserialize {} into model {}. ".format(kwargs, response) # type: ignore
- raise DeserializationError(msg + str(err))
+ raise DeserializationError(msg + str(err)) from err
else:
try:
for attr, value in attrs.items():
@@ -1572,15 +1706,16 @@ def _instantiate_model(self, response, attrs, additional_properties=None):
except Exception as exp:
msg = "Unable to populate response model. "
msg += "Type: {}, Error: {}".format(type(response), exp)
- raise DeserializationError(msg)
+ raise DeserializationError(msg) from exp
- def deserialize_data(self, data, data_type):
+ def deserialize_data(self, data, data_type): # pylint: disable=too-many-return-statements
"""Process data for deserialization according to data type.
:param str data: The response string to be deserialized.
:param str data_type: The type to deserialize to.
:raises: DeserializationError if deserialization fails.
:return: Deserialized object.
+ :rtype: object
"""
if data is None:
return data
@@ -1594,7 +1729,11 @@ def deserialize_data(self, data, data_type):
if isinstance(data, self.deserialize_expected_types.get(data_type, tuple())):
return data
- is_a_text_parsing_type = lambda x: x not in ["object", "[]", r"{}"]
+ is_a_text_parsing_type = lambda x: x not in [ # pylint: disable=unnecessary-lambda-assignment
+ "object",
+ "[]",
+ r"{}",
+ ]
if isinstance(data, ET.Element) and is_a_text_parsing_type(data_type) and not data.text:
return None
data_val = self.deserialize_type[data_type](data)
@@ -1613,15 +1752,15 @@ def deserialize_data(self, data, data_type):
except (ValueError, TypeError, AttributeError) as err:
msg = "Unable to deserialize response data."
msg += " Data: {}, {}".format(data, data_type)
- raise_with_traceback(DeserializationError, msg, err)
- else:
- return self._deserialize(obj_type, data)
+ raise DeserializationError(msg) from err
+ return self._deserialize(obj_type, data)
def deserialize_iter(self, attr, iter_type):
"""Deserialize an iterable.
:param list attr: Iterable to be deserialized.
:param str iter_type: The type of object in the iterable.
+ :return: Deserialized iterable.
:rtype: list
"""
if attr is None:
@@ -1638,6 +1777,7 @@ def deserialize_dict(self, attr, dict_type):
:param dict/list attr: Dictionary to be deserialized. Also accepts
a list of key, value pairs.
:param str dict_type: The object type of the items in the dictionary.
+ :return: Deserialized dictionary.
:rtype: dict
"""
if isinstance(attr, list):
@@ -1648,11 +1788,12 @@ def deserialize_dict(self, attr, dict_type):
attr = {el.tag: el.text for el in attr}
return {k: self.deserialize_data(v, dict_type) for k, v in attr.items()}
- def deserialize_object(self, attr, **kwargs):
+ def deserialize_object(self, attr, **kwargs): # pylint: disable=too-many-return-statements
"""Deserialize a generic object.
This will be handled as a dictionary.
:param dict attr: Dictionary to be deserialized.
+ :return: Deserialized object.
:rtype: dict
:raises: TypeError if non-builtin datatype encountered.
"""
@@ -1661,7 +1802,7 @@ def deserialize_object(self, attr, **kwargs):
if isinstance(attr, ET.Element):
# Do no recurse on XML, just return the tree as-is
return attr
- if isinstance(attr, basestring):
+ if isinstance(attr, str):
return self.deserialize_basic(attr, "str")
obj_type = type(attr)
if obj_type in self.basic_types:
@@ -1687,11 +1828,10 @@ def deserialize_object(self, attr, **kwargs):
pass
return deserialized
- else:
- error = "Cannot deserialize generic object with type: "
- raise TypeError(error + str(obj_type))
+ error = "Cannot deserialize generic object with type: "
+ raise TypeError(error + str(obj_type))
- def deserialize_basic(self, attr, data_type):
+ def deserialize_basic(self, attr, data_type): # pylint: disable=too-many-return-statements
"""Deserialize basic builtin data type from string.
Will attempt to convert to str, int, float and bool.
This function will also accept '1', '0', 'true' and 'false' as
@@ -1699,6 +1839,7 @@ def deserialize_basic(self, attr, data_type):
:param str attr: response string to be deserialized.
:param str data_type: deserialization data type.
+ :return: Deserialized basic type.
:rtype: str, int, float or bool
:raises: TypeError if string format is not valid.
"""
@@ -1710,24 +1851,23 @@ def deserialize_basic(self, attr, data_type):
if data_type == "str":
# None or '', node is empty string.
return ""
- else:
- # None or '', node with a strong type is None.
- # Don't try to model "empty bool" or "empty int"
- return None
+ # None or '', node with a strong type is None.
+ # Don't try to model "empty bool" or "empty int"
+ return None
if data_type == "bool":
if attr in [True, False, 1, 0]:
return bool(attr)
- elif isinstance(attr, basestring):
+ if isinstance(attr, str):
if attr.lower() in ["true", "1"]:
return True
- elif attr.lower() in ["false", "0"]:
+ if attr.lower() in ["false", "0"]:
return False
raise TypeError("Invalid boolean value: {}".format(attr))
if data_type == "str":
return self.deserialize_unicode(attr)
- return eval(data_type)(attr) # nosec
+ return eval(data_type)(attr) # nosec # pylint: disable=eval-used
@staticmethod
def deserialize_unicode(data):
@@ -1735,6 +1875,7 @@ def deserialize_unicode(data):
as a string.
:param str data: response string to be deserialized.
+ :return: Deserialized string.
:rtype: str or unicode
"""
# We might be here because we have an enum modeled as string,
@@ -1748,8 +1889,7 @@ def deserialize_unicode(data):
return data
except NameError:
return str(data)
- else:
- return str(data)
+ return str(data)
@staticmethod
def deserialize_enum(data, enum_obj):
@@ -1761,6 +1901,7 @@ def deserialize_enum(data, enum_obj):
:param str data: Response string to be deserialized. If this value is
None or invalid it will be returned as-is.
:param Enum enum_obj: Enum object to deserialize to.
+ :return: Deserialized enum object.
:rtype: Enum
"""
if isinstance(data, enum_obj) or data is None:
@@ -1769,12 +1910,11 @@ def deserialize_enum(data, enum_obj):
data = data.value
if isinstance(data, int):
# Workaround. We might consider remove it in the future.
- # https://github.com/Azure/azure-rest-api-specs/issues/141
try:
return list(enum_obj.__members__.values())[data]
- except IndexError:
+ except IndexError as exc:
error = "{!r} is not a valid index for enum {!r}"
- raise DeserializationError(error.format(data, enum_obj))
+ raise DeserializationError(error.format(data, enum_obj)) from exc
try:
return enum_obj(str(data))
except ValueError:
@@ -1790,6 +1930,7 @@ def deserialize_bytearray(attr):
"""Deserialize string into bytearray.
:param str attr: response string to be deserialized.
+ :return: Deserialized bytearray
:rtype: bytearray
:raises: TypeError if string format invalid.
"""
@@ -1802,6 +1943,7 @@ def deserialize_base64(attr):
"""Deserialize base64 encoded string into string.
:param str attr: response string to be deserialized.
+ :return: Deserialized base64 string
:rtype: bytearray
:raises: TypeError if string format invalid.
"""
@@ -1817,22 +1959,24 @@ def deserialize_decimal(attr):
"""Deserialize string into Decimal object.
:param str attr: response string to be deserialized.
- :rtype: Decimal
+ :return: Deserialized decimal
:raises: DeserializationError if string format invalid.
+ :rtype: decimal
"""
if isinstance(attr, ET.Element):
attr = attr.text
try:
- return decimal.Decimal(attr) # type: ignore
+ return decimal.Decimal(str(attr)) # type: ignore
except decimal.DecimalException as err:
msg = "Invalid decimal {}".format(attr)
- raise_with_traceback(DeserializationError, msg, err)
+ raise DeserializationError(msg) from err
@staticmethod
def deserialize_long(attr):
"""Deserialize string into long (Py2) or int (Py3).
:param str attr: response string to be deserialized.
+ :return: Deserialized int
:rtype: long or int
:raises: ValueError if string format invalid.
"""
@@ -1845,6 +1989,7 @@ def deserialize_duration(attr):
"""Deserialize ISO-8601 formatted string into TimeDelta object.
:param str attr: response string to be deserialized.
+ :return: Deserialized duration
:rtype: TimeDelta
:raises: DeserializationError if string format invalid.
"""
@@ -1854,15 +1999,15 @@ def deserialize_duration(attr):
duration = isodate.parse_duration(attr)
except (ValueError, OverflowError, AttributeError) as err:
msg = "Cannot deserialize duration object."
- raise_with_traceback(DeserializationError, msg, err)
- else:
- return duration
+ raise DeserializationError(msg) from err
+ return duration
@staticmethod
def deserialize_date(attr):
"""Deserialize ISO-8601 formatted string into Date object.
:param str attr: response string to be deserialized.
+ :return: Deserialized date
:rtype: Date
:raises: DeserializationError if string format invalid.
"""
@@ -1871,13 +2016,14 @@ def deserialize_date(attr):
if re.search(r"[^\W\d_]", attr, re.I + re.U): # type: ignore
raise DeserializationError("Date must have only digits and -. Received: %s" % attr)
# This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception.
- return isodate.parse_date(attr, defaultmonth=None, defaultday=None)
+ return isodate.parse_date(attr, defaultmonth=0, defaultday=0)
@staticmethod
def deserialize_time(attr):
"""Deserialize ISO-8601 formatted string into time object.
:param str attr: response string to be deserialized.
+ :return: Deserialized time
:rtype: datetime.time
:raises: DeserializationError if string format invalid.
"""
@@ -1892,6 +2038,7 @@ def deserialize_rfc(attr):
"""Deserialize RFC-1123 formatted string into Datetime object.
:param str attr: response string to be deserialized.
+ :return: Deserialized RFC datetime
:rtype: Datetime
:raises: DeserializationError if string format invalid.
"""
@@ -1906,15 +2053,15 @@ def deserialize_rfc(attr):
date_obj = date_obj.astimezone(tz=TZ_UTC)
except ValueError as err:
msg = "Cannot deserialize to rfc datetime object."
- raise_with_traceback(DeserializationError, msg, err)
- else:
- return date_obj
+ raise DeserializationError(msg) from err
+ return date_obj
@staticmethod
def deserialize_iso(attr):
"""Deserialize ISO-8601 formatted string into Datetime object.
:param str attr: response string to be deserialized.
+ :return: Deserialized ISO datetime
:rtype: Datetime
:raises: DeserializationError if string format invalid.
"""
@@ -1943,9 +2090,8 @@ def deserialize_iso(attr):
raise OverflowError("Hit max or min date")
except (ValueError, OverflowError, AttributeError) as err:
msg = "Cannot deserialize datetime object."
- raise_with_traceback(DeserializationError, msg, err)
- else:
- return date_obj
+ raise DeserializationError(msg) from err
+ return date_obj
@staticmethod
def deserialize_unix(attr):
@@ -1953,15 +2099,16 @@ def deserialize_unix(attr):
This is represented as seconds.
:param int attr: Object to be serialized.
+ :return: Deserialized datetime
:rtype: Datetime
:raises: DeserializationError if format invalid
"""
if isinstance(attr, ET.Element):
attr = int(attr.text) # type: ignore
try:
+ attr = int(attr)
date_obj = datetime.datetime.fromtimestamp(attr, TZ_UTC)
except ValueError as err:
msg = "Cannot deserialize to unix datetime object."
- raise_with_traceback(DeserializationError, msg, err)
- else:
- return date_obj
+ raise DeserializationError(msg) from err
+ return date_obj
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_vendor.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_vendor.py
deleted file mode 100644
index 9aad73fc743e7..0000000000000
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_vendor.py
+++ /dev/null
@@ -1,27 +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) AutoRest Code Generator.
-# Changes may cause incorrect behavior and will be lost if the code is regenerated.
-# --------------------------------------------------------------------------
-
-from azure.core.pipeline.transport import HttpRequest
-
-
-def _convert_request(request, files=None):
- data = request.content if not files else None
- request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data)
- if files:
- request.set_formdata_body(files)
- return request
-
-
-def _format_url_section(template, **kwargs):
- components = template.split("/")
- while components:
- try:
- return template.format(**kwargs)
- except KeyError as key:
- formatted_components = template.split("/")
- components = [c for c in formatted_components if "{}".format(key.args[0]) not in c]
- template = "/".join(components)
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_version.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_version.py
index 2eda207895836..e5754a47ce68f 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_version.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/_version.py
@@ -6,4 +6,4 @@
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
-VERSION = "2.0.0b2"
+VERSION = "1.0.0b1"
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/__init__.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/__init__.py
index 42051a8571a2c..ed872336d0d87 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/__init__.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/__init__.py
@@ -5,12 +5,18 @@
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
+# pylint: disable=wrong-import-position
-from ._alerts_management_client import AlertsManagementClient
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from ._patch import * # pylint: disable=unused-wildcard-import
+
+from ._alerts_management_client import AlertsManagementClient # type: ignore
try:
from ._patch import __all__ as _patch_all
- from ._patch import * # pylint: disable=unused-wildcard-import
+ from ._patch import *
except ImportError:
_patch_all = []
from ._patch import patch_sdk as _patch_sdk
@@ -18,6 +24,6 @@
__all__ = [
"AlertsManagementClient",
]
-__all__.extend([p for p in _patch_all if p not in __all__])
+__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore
_patch_sdk()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/_alerts_management_client.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/_alerts_management_client.py
index 3848d1701f828..2044b8c5d5ec2 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/_alerts_management_client.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/_alerts_management_client.py
@@ -8,15 +8,18 @@
from copy import deepcopy
from typing import Any, Awaitable, TYPE_CHECKING
+from typing_extensions import Self
+from azure.core.pipeline import policies
from azure.core.rest import AsyncHttpResponse, HttpRequest
from azure.mgmt.core import AsyncARMPipelineClient
+from azure.mgmt.core.policies import AsyncARMAutoResourceProviderRegistrationPolicy
from .. import models as _models
from .._serialization import Deserializer, Serializer
from ._configuration import AlertsManagementClientConfiguration
from .operations import (
- AlertProcessingRulesOperations,
+ AlertRuleRecommendationsOperations,
AlertsOperations,
Operations,
PrometheusRuleGroupsOperations,
@@ -24,16 +27,12 @@
)
if TYPE_CHECKING:
- # pylint: disable=unused-import,ungrouped-imports
from azure.core.credentials_async import AsyncTokenCredential
class AlertsManagementClient: # pylint: disable=client-accepts-api-version-keyword
"""AlertsManagement Client.
- :ivar alert_processing_rules: AlertProcessingRulesOperations operations
- :vartype alert_processing_rules:
- azure.mgmt.alertsmanagement.aio.operations.AlertProcessingRulesOperations
:ivar prometheus_rule_groups: PrometheusRuleGroupsOperations operations
:vartype prometheus_rule_groups:
azure.mgmt.alertsmanagement.aio.operations.PrometheusRuleGroupsOperations
@@ -43,6 +42,9 @@ class AlertsManagementClient: # pylint: disable=client-accepts-api-version-keyw
:vartype alerts: azure.mgmt.alertsmanagement.aio.operations.AlertsOperations
:ivar smart_groups: SmartGroupsOperations operations
:vartype smart_groups: azure.mgmt.alertsmanagement.aio.operations.SmartGroupsOperations
+ :ivar alert_rule_recommendations: AlertRuleRecommendationsOperations operations
+ :vartype alert_rule_recommendations:
+ azure.mgmt.alertsmanagement.aio.operations.AlertRuleRecommendationsOperations
: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. Required.
@@ -61,23 +63,43 @@ def __init__(
self._config = AlertsManagementClientConfiguration(
credential=credential, subscription_id=subscription_id, **kwargs
)
- self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **kwargs)
+ _policies = kwargs.pop("policies", None)
+ if _policies is None:
+ _policies = [
+ policies.RequestIdPolicy(**kwargs),
+ self._config.headers_policy,
+ self._config.user_agent_policy,
+ self._config.proxy_policy,
+ policies.ContentDecodePolicy(**kwargs),
+ AsyncARMAutoResourceProviderRegistrationPolicy(),
+ self._config.redirect_policy,
+ self._config.retry_policy,
+ self._config.authentication_policy,
+ self._config.custom_hook_policy,
+ self._config.logging_policy,
+ policies.DistributedTracingPolicy(**kwargs),
+ policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None,
+ self._config.http_logging_policy,
+ ]
+ self._client: AsyncARMPipelineClient = AsyncARMPipelineClient(base_url=base_url, policies=_policies, **kwargs)
client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self._serialize.client_side_validation = False
- self.alert_processing_rules = AlertProcessingRulesOperations(
- self._client, self._config, self._serialize, self._deserialize
- )
self.prometheus_rule_groups = PrometheusRuleGroupsOperations(
self._client, self._config, self._serialize, self._deserialize
)
self.operations = Operations(self._client, self._config, self._serialize, self._deserialize)
self.alerts = AlertsOperations(self._client, self._config, self._serialize, self._deserialize)
self.smart_groups = SmartGroupsOperations(self._client, self._config, self._serialize, self._deserialize)
+ self.alert_rule_recommendations = AlertRuleRecommendationsOperations(
+ self._client, self._config, self._serialize, self._deserialize
+ )
- def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]:
+ def _send_request(
+ self, request: HttpRequest, *, stream: bool = False, **kwargs: Any
+ ) -> Awaitable[AsyncHttpResponse]:
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
@@ -97,14 +119,14 @@ def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncH
request_copy = deepcopy(request)
request_copy.url = self._client.format_url(request_copy.url)
- return self._client.send_request(request_copy, **kwargs)
+ return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore
async def close(self) -> None:
await self._client.close()
- async def __aenter__(self) -> "AlertsManagementClient":
+ async def __aenter__(self) -> Self:
await self._client.__aenter__()
return self
- async def __aexit__(self, *exc_details) -> None:
+ async def __aexit__(self, *exc_details: Any) -> None:
await self._client.__aexit__(*exc_details)
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/_configuration.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/_configuration.py
index 4295ad594068b..40f54de3c0335 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/_configuration.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/_configuration.py
@@ -8,18 +8,16 @@
from typing import Any, TYPE_CHECKING
-from azure.core.configuration import Configuration
from azure.core.pipeline import policies
from azure.mgmt.core.policies import ARMHttpLoggingPolicy, AsyncARMChallengeAuthenticationPolicy
from .._version import VERSION
if TYPE_CHECKING:
- # pylint: disable=unused-import,ungrouped-imports
from azure.core.credentials_async import AsyncTokenCredential
-class AlertsManagementClientConfiguration(Configuration): # pylint: disable=too-many-instance-attributes
+class AlertsManagementClientConfiguration: # pylint: disable=too-many-instance-attributes
"""Configuration for AlertsManagementClient.
Note that all parameters used to create this instance are saved as instance
@@ -32,7 +30,6 @@ class AlertsManagementClientConfiguration(Configuration): # pylint: disable=too
"""
def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None:
- super(AlertsManagementClientConfiguration, self).__init__(**kwargs)
if credential is None:
raise ValueError("Parameter 'credential' must not be None.")
if subscription_id is None:
@@ -42,6 +39,7 @@ def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **k
self.subscription_id = subscription_id
self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"])
kwargs.setdefault("sdk_moniker", "mgmt-alertsmanagement/{}".format(VERSION))
+ self.polling_interval = kwargs.get("polling_interval", 30)
self._configure(**kwargs)
def _configure(self, **kwargs: Any) -> None:
@@ -50,9 +48,9 @@ def _configure(self, **kwargs: Any) -> None:
self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs)
self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs)
self.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**kwargs)
- self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs)
self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs)
self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs)
+ self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs)
self.authentication_policy = kwargs.get("authentication_policy")
if self.credential and not self.authentication_policy:
self.authentication_policy = AsyncARMChallengeAuthenticationPolicy(
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/__init__.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/__init__.py
index c8dd1e48dcf0d..4691a31fa9983 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/__init__.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/__init__.py
@@ -5,23 +5,29 @@
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
+# pylint: disable=wrong-import-position
-from ._alert_processing_rules_operations import AlertProcessingRulesOperations
-from ._prometheus_rule_groups_operations import PrometheusRuleGroupsOperations
-from ._operations import Operations
-from ._alerts_operations import AlertsOperations
-from ._smart_groups_operations import SmartGroupsOperations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from ._patch import * # pylint: disable=unused-wildcard-import
+
+from ._prometheus_rule_groups_operations import PrometheusRuleGroupsOperations # type: ignore
+from ._operations import Operations # type: ignore
+from ._alerts_operations import AlertsOperations # type: ignore
+from ._smart_groups_operations import SmartGroupsOperations # type: ignore
+from ._alert_rule_recommendations_operations import AlertRuleRecommendationsOperations # type: ignore
from ._patch import __all__ as _patch_all
-from ._patch import * # pylint: disable=unused-wildcard-import
+from ._patch import *
from ._patch import patch_sdk as _patch_sdk
__all__ = [
- "AlertProcessingRulesOperations",
"PrometheusRuleGroupsOperations",
"Operations",
"AlertsOperations",
"SmartGroupsOperations",
+ "AlertRuleRecommendationsOperations",
]
-__all__.extend([p for p in _patch_all if p not in __all__])
+__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore
_patch_sdk()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_alert_processing_rules_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_alert_processing_rules_operations.py
deleted file mode 100644
index 4ffa545dcedd0..0000000000000
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_alert_processing_rules_operations.py
+++ /dev/null
@@ -1,641 +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) AutoRest Code Generator.
-# Changes may cause incorrect behavior and will be lost if the code is regenerated.
-# --------------------------------------------------------------------------
-import sys
-from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload
-
-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.pipeline.transport import AsyncHttpResponse
-from azure.core.rest import 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 ..._vendor import _convert_request
-from ...operations._alert_processing_rules_operations import (
- build_create_or_update_request,
- build_delete_request,
- build_get_by_name_request,
- build_list_by_resource_group_request,
- build_list_by_subscription_request,
- build_update_request,
-)
-
-if sys.version_info >= (3, 8):
- from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports
-else:
- from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports
-T = TypeVar("T")
-ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]]
-
-
-class AlertProcessingRulesOperations:
- """
- .. warning::
- **DO NOT** instantiate this class directly.
-
- Instead, you should access the following operations through
- :class:`~azure.mgmt.alertsmanagement.aio.AlertsManagementClient`'s
- :attr:`alert_processing_rules` attribute.
- """
-
- models = _models
-
- def __init__(self, *args, **kwargs) -> None:
- input_args = list(args)
- self._client = input_args.pop(0) if input_args else kwargs.pop("client")
- self._config = input_args.pop(0) if input_args else kwargs.pop("config")
- self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer")
- self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer")
-
- @distributed_trace
- def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.AlertProcessingRule"]:
- """List all alert processing rules in a subscription.
-
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: An iterator like instance of either AlertProcessingRule or the result of cls(response)
- :rtype:
- ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.alertsmanagement.models.AlertProcessingRule]
- :raises ~azure.core.exceptions.HttpResponseError:
- """
- _headers = kwargs.pop("headers", {}) or {}
- _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
-
- api_version: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- cls: ClsType[_models.AlertProcessingRulesList] = kwargs.pop("cls", None)
-
- error_map = {
- 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,
- template_url=self.list_by_subscription.metadata["url"],
- headers=_headers,
- params=_params,
- )
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
-
- else:
- request = HttpRequest("GET", next_link)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
- request.method = "GET"
- return request
-
- async def extract_data(pipeline_response):
- deserialized = self._deserialize("AlertProcessingRulesList", 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)
-
- pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
- )
- response = pipeline_response.http_response
-
- if response.status_code not in [200]:
- map_error(status_code=response.status_code, response=response, error_map=error_map)
- 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)
-
- list_by_subscription.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/actionRules"
- }
-
- @distributed_trace
- def list_by_resource_group(
- self, resource_group_name: str, **kwargs: Any
- ) -> AsyncIterable["_models.AlertProcessingRule"]:
- """List all alert processing rules in a resource group.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: An iterator like instance of either AlertProcessingRule or the result of cls(response)
- :rtype:
- ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.alertsmanagement.models.AlertProcessingRule]
- :raises ~azure.core.exceptions.HttpResponseError:
- """
- _headers = kwargs.pop("headers", {}) or {}
- _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
-
- api_version: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- cls: ClsType[_models.AlertProcessingRulesList] = kwargs.pop("cls", None)
-
- error_map = {
- 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,
- template_url=self.list_by_resource_group.metadata["url"],
- headers=_headers,
- params=_params,
- )
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
-
- else:
- request = HttpRequest("GET", next_link)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
- request.method = "GET"
- return request
-
- async def extract_data(pipeline_response):
- deserialized = self._deserialize("AlertProcessingRulesList", 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)
-
- pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
- )
- response = pipeline_response.http_response
-
- if response.status_code not in [200]:
- map_error(status_code=response.status_code, response=response, error_map=error_map)
- 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)
-
- list_by_resource_group.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/actionRules"
- }
-
- @distributed_trace_async
- async def get_by_name(
- self, resource_group_name: str, alert_processing_rule_name: str, **kwargs: Any
- ) -> _models.AlertProcessingRule:
- """Get an alert processing rule by name.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name of the alert processing rule that needs to be
- fetched. Required.
- :type alert_processing_rule_name: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :raises ~azure.core.exceptions.HttpResponseError:
- """
- error_map = {
- 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: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- cls: ClsType[_models.AlertProcessingRule] = kwargs.pop("cls", None)
-
- request = build_get_by_name_request(
- resource_group_name=resource_group_name,
- alert_processing_rule_name=alert_processing_rule_name,
- subscription_id=self._config.subscription_id,
- api_version=api_version,
- template_url=self.get_by_name.metadata["url"],
- headers=_headers,
- params=_params,
- )
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
-
- pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
- )
-
- response = pipeline_response.http_response
-
- if response.status_code not in [200]:
- map_error(status_code=response.status_code, response=response, error_map=error_map)
- error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
- raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
-
- response_headers = {}
- response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
-
- deserialized = self._deserialize("AlertProcessingRule", pipeline_response)
-
- if cls:
- return cls(pipeline_response, deserialized, response_headers)
-
- return deserialized
-
- get_by_name.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/actionRules/{alertProcessingRuleName}"
- }
-
- @overload
- async def create_or_update(
- self,
- resource_group_name: str,
- alert_processing_rule_name: str,
- alert_processing_rule: _models.AlertProcessingRule,
- *,
- content_type: str = "application/json",
- **kwargs: Any
- ) -> _models.AlertProcessingRule:
- """Create or update an alert processing rule.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name of the alert processing rule that needs to be
- created/updated. Required.
- :type alert_processing_rule_name: str
- :param alert_processing_rule: Alert processing rule to be created/updated. Required.
- :type alert_processing_rule: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
- Default value is "application/json".
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :raises ~azure.core.exceptions.HttpResponseError:
- """
-
- @overload
- async def create_or_update(
- self,
- resource_group_name: str,
- alert_processing_rule_name: str,
- alert_processing_rule: IO,
- *,
- content_type: str = "application/json",
- **kwargs: Any
- ) -> _models.AlertProcessingRule:
- """Create or update an alert processing rule.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name of the alert processing rule that needs to be
- created/updated. Required.
- :type alert_processing_rule_name: str
- :param alert_processing_rule: Alert processing rule to be created/updated. Required.
- :type alert_processing_rule: IO
- :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
- Default value is "application/json".
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :raises ~azure.core.exceptions.HttpResponseError:
- """
-
- @distributed_trace_async
- async def create_or_update(
- self,
- resource_group_name: str,
- alert_processing_rule_name: str,
- alert_processing_rule: Union[_models.AlertProcessingRule, IO],
- **kwargs: Any
- ) -> _models.AlertProcessingRule:
- """Create or update an alert processing rule.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name of the alert processing rule that needs to be
- created/updated. Required.
- :type alert_processing_rule_name: str
- :param alert_processing_rule: Alert processing rule to be created/updated. Is either a model
- type or a IO type. Required.
- :type alert_processing_rule: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule or IO
- :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
- Default value is None.
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :raises ~azure.core.exceptions.HttpResponseError:
- """
- error_map = {
- 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: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
- cls: ClsType[_models.AlertProcessingRule] = kwargs.pop("cls", None)
-
- content_type = content_type or "application/json"
- _json = None
- _content = None
- if isinstance(alert_processing_rule, (IO, bytes)):
- _content = alert_processing_rule
- else:
- _json = self._serialize.body(alert_processing_rule, "AlertProcessingRule")
-
- request = build_create_or_update_request(
- resource_group_name=resource_group_name,
- alert_processing_rule_name=alert_processing_rule_name,
- subscription_id=self._config.subscription_id,
- api_version=api_version,
- content_type=content_type,
- json=_json,
- content=_content,
- template_url=self.create_or_update.metadata["url"],
- headers=_headers,
- params=_params,
- )
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
-
- pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **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)
-
- response_headers = {}
- if response.status_code == 200:
- response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
-
- deserialized = self._deserialize("AlertProcessingRule", pipeline_response)
-
- if response.status_code == 201:
- response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
-
- deserialized = self._deserialize("AlertProcessingRule", pipeline_response)
-
- if cls:
- return cls(pipeline_response, deserialized, response_headers) # type: ignore
-
- return deserialized # type: ignore
-
- create_or_update.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/actionRules/{alertProcessingRuleName}"
- }
-
- @distributed_trace_async
- async def delete( # pylint: disable=inconsistent-return-statements
- self, resource_group_name: str, alert_processing_rule_name: str, **kwargs: Any
- ) -> None:
- """Delete an alert processing rule.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name of the alert processing rule that needs to be
- deleted. Required.
- :type alert_processing_rule_name: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: None or the result of cls(response)
- :rtype: None
- :raises ~azure.core.exceptions.HttpResponseError:
- """
- error_map = {
- 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: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- cls: ClsType[None] = kwargs.pop("cls", None)
-
- request = build_delete_request(
- resource_group_name=resource_group_name,
- alert_processing_rule_name=alert_processing_rule_name,
- subscription_id=self._config.subscription_id,
- api_version=api_version,
- template_url=self.delete.metadata["url"],
- headers=_headers,
- params=_params,
- )
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
-
- pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **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)
-
- response_headers = {}
- if response.status_code == 200:
- response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
-
- if response.status_code == 204:
- response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
-
- if cls:
- return cls(pipeline_response, None, response_headers)
-
- delete.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/actionRules/{alertProcessingRuleName}"
- }
-
- @overload
- async def update(
- self,
- resource_group_name: str,
- alert_processing_rule_name: str,
- alert_processing_rule_patch: _models.PatchObject,
- *,
- content_type: str = "application/json",
- **kwargs: Any
- ) -> _models.AlertProcessingRule:
- """Enable, disable, or update tags for an alert processing rule.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name that needs to be updated. Required.
- :type alert_processing_rule_name: str
- :param alert_processing_rule_patch: Parameters supplied to the operation. Required.
- :type alert_processing_rule_patch: ~azure.mgmt.alertsmanagement.models.PatchObject
- :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
- Default value is "application/json".
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :raises ~azure.core.exceptions.HttpResponseError:
- """
-
- @overload
- async def update(
- self,
- resource_group_name: str,
- alert_processing_rule_name: str,
- alert_processing_rule_patch: IO,
- *,
- content_type: str = "application/json",
- **kwargs: Any
- ) -> _models.AlertProcessingRule:
- """Enable, disable, or update tags for an alert processing rule.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name that needs to be updated. Required.
- :type alert_processing_rule_name: str
- :param alert_processing_rule_patch: Parameters supplied to the operation. Required.
- :type alert_processing_rule_patch: IO
- :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
- Default value is "application/json".
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :raises ~azure.core.exceptions.HttpResponseError:
- """
-
- @distributed_trace_async
- async def update(
- self,
- resource_group_name: str,
- alert_processing_rule_name: str,
- alert_processing_rule_patch: Union[_models.PatchObject, IO],
- **kwargs: Any
- ) -> _models.AlertProcessingRule:
- """Enable, disable, or update tags for an alert processing rule.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name that needs to be updated. Required.
- :type alert_processing_rule_name: str
- :param alert_processing_rule_patch: Parameters supplied to the operation. Is either a model
- type or a IO type. Required.
- :type alert_processing_rule_patch: ~azure.mgmt.alertsmanagement.models.PatchObject or IO
- :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
- Default value is None.
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :raises ~azure.core.exceptions.HttpResponseError:
- """
- error_map = {
- 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: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
- cls: ClsType[_models.AlertProcessingRule] = kwargs.pop("cls", None)
-
- content_type = content_type or "application/json"
- _json = None
- _content = None
- if isinstance(alert_processing_rule_patch, (IO, bytes)):
- _content = alert_processing_rule_patch
- else:
- _json = self._serialize.body(alert_processing_rule_patch, "PatchObject")
-
- request = build_update_request(
- resource_group_name=resource_group_name,
- alert_processing_rule_name=alert_processing_rule_name,
- subscription_id=self._config.subscription_id,
- api_version=api_version,
- content_type=content_type,
- json=_json,
- content=_content,
- template_url=self.update.metadata["url"],
- headers=_headers,
- params=_params,
- )
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
-
- pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
- )
-
- response = pipeline_response.http_response
-
- if response.status_code not in [200]:
- map_error(status_code=response.status_code, response=response, error_map=error_map)
- error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
- raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
-
- response_headers = {}
- response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
-
- deserialized = self._deserialize("AlertProcessingRule", pipeline_response)
-
- if cls:
- return cls(pipeline_response, deserialized, response_headers)
-
- return deserialized
-
- update.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/actionRules/{alertProcessingRuleName}"
- }
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_alert_rule_recommendations_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_alert_rule_recommendations_operations.py
new file mode 100644
index 0000000000000..a867c48772866
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_alert_rule_recommendations_operations.py
@@ -0,0 +1,198 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) AutoRest Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+import sys
+from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar
+
+from azure.core.async_paging import AsyncItemPaged, AsyncList
+from azure.core.exceptions import (
+ ClientAuthenticationError,
+ HttpResponseError,
+ ResourceExistsError,
+ ResourceNotFoundError,
+ ResourceNotModifiedError,
+ map_error,
+)
+from azure.core.pipeline import PipelineResponse
+from azure.core.rest import AsyncHttpResponse, HttpRequest
+from azure.core.tracing.decorator import distributed_trace
+from azure.core.utils import case_insensitive_dict
+from azure.mgmt.core.exceptions import ARMErrorFormat
+
+from ... import models as _models
+from ...operations._alert_rule_recommendations_operations import (
+ build_list_by_resource_request,
+ build_list_by_target_type_request,
+)
+
+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]]
+
+
+class AlertRuleRecommendationsOperations:
+ """
+ .. warning::
+ **DO NOT** instantiate this class directly.
+
+ Instead, you should access the following operations through
+ :class:`~azure.mgmt.alertsmanagement.aio.AlertsManagementClient`'s
+ :attr:`alert_rule_recommendations` attribute.
+ """
+
+ models = _models
+
+ def __init__(self, *args, **kwargs) -> None:
+ input_args = list(args)
+ self._client = input_args.pop(0) if input_args else kwargs.pop("client")
+ self._config = input_args.pop(0) if input_args else kwargs.pop("config")
+ self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer")
+ self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer")
+
+ @distributed_trace
+ def list_by_resource(
+ self, resource_uri: str, **kwargs: Any
+ ) -> AsyncIterable["_models.AlertRuleRecommendationResource"]:
+ """Retrieve alert rule recommendations for a resource.
+
+ :param resource_uri: The identifier of the resource. Required.
+ :type resource_uri: str
+ :return: An iterator like instance of either AlertRuleRecommendationResource or the result of
+ cls(response)
+ :rtype:
+ ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.alertsmanagement.models.AlertRuleRecommendationResource]
+ :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", "2023-08-01-preview"))
+ cls: ClsType[_models.AlertRuleRecommendationsListResponse] = 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_request(
+ resource_uri=resource_uri,
+ api_version=api_version,
+ headers=_headers,
+ params=_params,
+ )
+ _request.url = self._client.format_url(_request.url)
+
+ else:
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
+
+ async def extract_data(pipeline_response):
+ deserialized = self._deserialize("AlertRuleRecommendationsListResponse", 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_target_type(
+ self, target_type: str, **kwargs: Any
+ ) -> AsyncIterable["_models.AlertRuleRecommendationResource"]:
+ """Retrieve alert rule recommendations for a target type.
+
+ :param target_type: The recommendations target type. Required.
+ :type target_type: str
+ :return: An iterator like instance of either AlertRuleRecommendationResource or the result of
+ cls(response)
+ :rtype:
+ ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.alertsmanagement.models.AlertRuleRecommendationResource]
+ :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", "2023-08-01-preview"))
+ cls: ClsType[_models.AlertRuleRecommendationsListResponse] = 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_target_type_request(
+ subscription_id=self._config.subscription_id,
+ target_type=target_type,
+ api_version=api_version,
+ headers=_headers,
+ params=_params,
+ )
+ _request.url = self._client.format_url(_request.url)
+
+ else:
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
+
+ async def extract_data(pipeline_response):
+ deserialized = self._deserialize("AlertRuleRecommendationsListResponse", 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)
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_alerts_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_alerts_operations.py
index 4e3955d1a17e8..4537c357f4492 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_alerts_operations.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_alerts_operations.py
@@ -1,4 +1,3 @@
-# pylint: disable=too-many-lines
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
@@ -6,6 +5,7 @@
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
+from io import IOBase
import sys
from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload
@@ -19,28 +19,28 @@
map_error,
)
from azure.core.pipeline import PipelineResponse
-from azure.core.pipeline.transport import AsyncHttpResponse
-from azure.core.rest import HttpRequest
+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 ..._vendor import _convert_request
from ...operations._alerts_operations import (
build_change_state_request,
build_get_all_request,
build_get_by_id_request,
+ build_get_enrichments_request,
build_get_history_request,
build_get_summary_request,
+ build_list_enrichments_request,
build_meta_data_request,
)
-if sys.version_info >= (3, 8):
- from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports
+if sys.version_info >= (3, 9):
+ from collections.abc import MutableMapping
else:
- from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports
+ from typing import MutableMapping # type: ignore
T = TypeVar("T")
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]]
@@ -71,12 +71,11 @@ async def meta_data(self, identifier: Union[str, _models.Identifier], **kwargs:
:param identifier: Identification of the information to be retrieved by API call.
"MonitorServiceList" Required.
:type identifier: str or ~azure.mgmt.alertsmanagement.models.Identifier
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: AlertsMetaData or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.AlertsMetaData
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -87,44 +86,40 @@ async def meta_data(self, identifier: Union[str, _models.Identifier], **kwargs:
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
cls: ClsType[_models.AlertsMetaData] = kwargs.pop("cls", None)
- request = build_meta_data_request(
+ _request = build_meta_data_request(
identifier=identifier,
api_version=api_version,
- template_url=self.meta_data.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated2, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("AlertsMetaData", pipeline_response)
+ deserialized = self._deserialize("AlertsMetaData", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- return deserialized
-
- meta_data.metadata = {"url": "/providers/Microsoft.AlertsManagement/alertsMetaData"}
+ return deserialized # type: ignore
@distributed_trace
def get_all(
self,
+ scope: str,
target_resource: Optional[str] = None,
target_resource_type: Optional[str] = None,
target_resource_group: Optional[str] = None,
@@ -148,6 +143,8 @@ def get_all(
(e.g. time range). The results can then be sorted on the basis specific fields, with the
default being lastModifiedDateTime.
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
:param target_resource: Filter by target resource( which is full ARM ID) Default value is
select all. Default value is None.
:type target_resource: str
@@ -161,7 +158,7 @@ def get_all(
value is select all. Known values are: "Application Insights", "ActivityLog Administrative",
"ActivityLog Security", "ActivityLog Recommendation", "ActivityLog Policy", "ActivityLog
Autoscale", "Log Analytics", "Nagios", "Platform", "SCOM", "ServiceHealth", "SmartDetector",
- "VM Insights", and "Zabbix". Default value is None.
+ "VM Insights", "Zabbix", and "Resource Health". Default value is None.
:type monitor_service: str or ~azure.mgmt.alertsmanagement.models.MonitorService
:param monitor_condition: Filter by monitor condition which is either 'Fired' or 'Resolved'.
Default value is to select all. Known values are: "Fired" and "Resolved". Default value is
@@ -211,7 +208,6 @@ def get_all(
values is within 30 days from query time. Either timeRange or customTimeRange could be used
but not both. Default is none. Default value is None.
:type custom_time_range: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either Alert or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.alertsmanagement.models.Alert]
:raises ~azure.core.exceptions.HttpResponseError:
@@ -219,12 +215,10 @@ def get_all(
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
cls: ClsType[_models.AlertsList] = kwargs.pop("cls", None)
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -235,8 +229,8 @@ def get_all(
def prepare_request(next_link=None):
if not next_link:
- request = build_get_all_request(
- subscription_id=self._config.subscription_id,
+ _request = build_get_all_request(
+ scope=scope,
target_resource=target_resource,
target_resource_type=target_resource_type,
target_resource_group=target_resource_group,
@@ -255,19 +249,16 @@ def prepare_request(next_link=None):
time_range=time_range,
custom_time_range=custom_time_range,
api_version=api_version,
- template_url=self.get_all.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
else:
- request = HttpRequest("GET", next_link)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
- request.method = "GET"
- return request
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
async def extract_data(pipeline_response):
deserialized = self._deserialize("AlertsList", pipeline_response)
@@ -277,38 +268,38 @@ async def extract_data(pipeline_response):
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
- request = prepare_request(next_link)
+ _request = prepare_request(next_link)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated2, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
- get_all.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alerts"}
-
@distributed_trace_async
- async def get_by_id(self, alert_id: str, **kwargs: Any) -> _models.Alert:
+ async def get_by_id(self, scope: str, alert_id: str, **kwargs: Any) -> _models.Alert:
"""Get a specific alert.
Get information related to a specific alert.
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
:param alert_id: Unique ID of an alert instance. Required.
:type alert_id: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: Alert or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.Alert
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -319,47 +310,41 @@ async def get_by_id(self, alert_id: str, **kwargs: Any) -> _models.Alert:
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
cls: ClsType[_models.Alert] = kwargs.pop("cls", None)
- request = build_get_by_id_request(
+ _request = build_get_by_id_request(
+ scope=scope,
alert_id=alert_id,
- subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.get_by_id.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated2, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("Alert", pipeline_response)
+ deserialized = self._deserialize("Alert", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
-
- return deserialized
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- get_by_id.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alerts/{alertId}"
- }
+ return deserialized # type: ignore
@overload
async def change_state(
self,
+ scope: str,
alert_id: str,
new_state: Union[str, _models.AlertState],
comment: Optional[_models.Comments] = None,
@@ -369,6 +354,8 @@ async def change_state(
) -> _models.Alert:
"""Change the state of an alert.
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
:param alert_id: Unique ID of an alert instance. Required.
:type alert_id: str
:param new_state: New state of the alert. Known values are: "New", "Acknowledged", and
@@ -379,7 +366,6 @@ async def change_state(
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: Alert or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.Alert
:raises ~azure.core.exceptions.HttpResponseError:
@@ -388,26 +374,28 @@ async def change_state(
@overload
async def change_state(
self,
+ scope: str,
alert_id: str,
new_state: Union[str, _models.AlertState],
- comment: Optional[IO] = None,
+ comment: Optional[IO[bytes]] = None,
*,
content_type: str = "application/json",
**kwargs: Any
) -> _models.Alert:
"""Change the state of an alert.
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
:param alert_id: Unique ID of an alert instance. Required.
:type alert_id: str
:param new_state: New state of the alert. Known values are: "New", "Acknowledged", and
"Closed". Required.
:type new_state: str or ~azure.mgmt.alertsmanagement.models.AlertState
:param comment: reason of change alert state. Default value is None.
- :type comment: IO
+ :type comment: IO[bytes]
:keyword content_type: Body Parameter content-type. Content type parameter for binary body.
Default value is "application/json".
:paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: Alert or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.Alert
:raises ~azure.core.exceptions.HttpResponseError:
@@ -416,30 +404,29 @@ async def change_state(
@distributed_trace_async
async def change_state(
self,
+ scope: str,
alert_id: str,
new_state: Union[str, _models.AlertState],
- comment: Optional[Union[_models.Comments, IO]] = None,
+ comment: Optional[Union[_models.Comments, IO[bytes]]] = None,
**kwargs: Any
) -> _models.Alert:
"""Change the state of an alert.
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
:param alert_id: Unique ID of an alert instance. Required.
:type alert_id: str
:param new_state: New state of the alert. Known values are: "New", "Acknowledged", and
"Closed". Required.
:type new_state: str or ~azure.mgmt.alertsmanagement.models.AlertState
- :param comment: reason of change alert state. Is either a model type or a IO type. Default
- value is None.
- :type comment: ~azure.mgmt.alertsmanagement.models.Comments or IO
- :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
+ :param comment: reason of change alert state. Is either a Comments type or a IO[bytes] type.
Default value is None.
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
+ :type comment: ~azure.mgmt.alertsmanagement.models.Comments or IO[bytes]
:return: Alert or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.Alert
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -450,16 +437,14 @@ async def change_state(
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
cls: ClsType[_models.Alert] = kwargs.pop("cls", None)
content_type = content_type or "application/json"
_json = None
_content = None
- if isinstance(comment, (IO, bytes)):
+ if isinstance(comment, (IOBase, bytes)):
_content = comment
else:
if comment is not None:
@@ -467,56 +452,52 @@ async def change_state(
else:
_json = None
- request = build_change_state_request(
+ _request = build_change_state_request(
+ scope=scope,
alert_id=alert_id,
- subscription_id=self._config.subscription_id,
new_state=new_state,
api_version=api_version,
content_type=content_type,
json=_json,
content=_content,
- template_url=self.change_state.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated2, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("Alert", pipeline_response)
+ deserialized = self._deserialize("Alert", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- return deserialized
-
- change_state.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alerts/{alertId}/changestate"
- }
+ return deserialized # type: ignore
@distributed_trace_async
- async def get_history(self, alert_id: str, **kwargs: Any) -> _models.AlertModification:
+ async def get_history(self, scope: str, alert_id: str, **kwargs: Any) -> _models.AlertModification:
"""Get the history of an alert, which captures any monitor condition changes (Fired/Resolved) and
alert state changes (New/Acknowledged/Closed).
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
:param alert_id: Unique ID of an alert instance. Required.
:type alert_id: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: AlertModification or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.AlertModification
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -527,47 +508,41 @@ async def get_history(self, alert_id: str, **kwargs: Any) -> _models.AlertModifi
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
cls: ClsType[_models.AlertModification] = kwargs.pop("cls", None)
- request = build_get_history_request(
+ _request = build_get_history_request(
+ scope=scope,
alert_id=alert_id,
- subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.get_history.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated2, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("AlertModification", pipeline_response)
+ deserialized = self._deserialize("AlertModification", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
-
- return deserialized
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- get_history.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alerts/{alertId}/history"
- }
+ return deserialized # type: ignore
@distributed_trace_async
async def get_summary(
self,
+ scope: str,
groupby: Union[str, _models.AlertsSummaryGroupByFields],
include_smart_groups_count: Optional[bool] = None,
target_resource: Optional[str] = None,
@@ -585,6 +560,8 @@ async def get_summary(
"""Get a summarized count of your alerts grouped by various parameters (e.g. grouping by
'Severity' returns the count of alerts for each severity).
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
:param groupby: This parameter allows the result set to be grouped by input fields (Maximum 2
comma separated fields supported). For example, groupby=severity or
groupby=severity,alertstate. Known values are: "severity", "alertState", "monitorCondition",
@@ -606,7 +583,7 @@ async def get_summary(
value is select all. Known values are: "Application Insights", "ActivityLog Administrative",
"ActivityLog Security", "ActivityLog Recommendation", "ActivityLog Policy", "ActivityLog
Autoscale", "Log Analytics", "Nagios", "Platform", "SCOM", "ServiceHealth", "SmartDetector",
- "VM Insights", and "Zabbix". Default value is None.
+ "VM Insights", "Zabbix", and "Resource Health". Default value is None.
:type monitor_service: str or ~azure.mgmt.alertsmanagement.models.MonitorService
:param monitor_condition: Filter by monitor condition which is either 'Fired' or 'Resolved'.
Default value is to select all. Known values are: "Fired" and "Resolved". Default value is
@@ -629,12 +606,11 @@ async def get_summary(
values is within 30 days from query time. Either timeRange or customTimeRange could be used
but not both. Default is none. Default value is None.
:type custom_time_range: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: AlertsSummary or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.AlertsSummary
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -645,13 +621,11 @@ async def get_summary(
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
cls: ClsType[_models.AlertsSummary] = kwargs.pop("cls", None)
- request = build_get_summary_request(
- subscription_id=self._config.subscription_id,
+ _request = build_get_summary_request(
+ scope=scope,
groupby=groupby,
include_smart_groups_count=include_smart_groups_count,
target_resource=target_resource,
@@ -665,29 +639,153 @@ async def get_summary(
time_range=time_range,
custom_time_range=custom_time_range,
api_version=api_version,
- template_url=self.get_summary.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated2, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("AlertsSummary", pipeline_response)
+ deserialized = self._deserialize("AlertsSummary", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
+ return cls(pipeline_response, deserialized, {}) # type: ignore
+
+ return deserialized # type: ignore
+
+ @distributed_trace
+ def list_enrichments(
+ self, scope: str, alert_id: str, **kwargs: Any
+ ) -> AsyncIterable["_models.AlertEnrichmentResponse"]:
+ """List the enrichments of an alert. It returns a collection of one object named default.
+
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
+ :param alert_id: Unique ID of an alert instance. Required.
+ :type alert_id: str
+ :return: An iterator like instance of either AlertEnrichmentResponse or the result of
+ cls(response)
+ :rtype:
+ ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.alertsmanagement.models.AlertEnrichmentResponse]
+ :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", "2024-01-01-preview"))
+ cls: ClsType[_models.AlertEnrichmentsList] = 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_enrichments_request(
+ scope=scope,
+ alert_id=alert_id,
+ api_version=api_version,
+ headers=_headers,
+ params=_params,
+ )
+ _request.url = self._client.format_url(_request.url)
+
+ else:
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
+
+ async def extract_data(pipeline_response):
+ deserialized = self._deserialize("AlertEnrichmentsList", pipeline_response)
+ list_of_elem = deserialized.value
+ if cls:
+ list_of_elem = cls(list_of_elem) # type: ignore
+ return 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.ErrorResponseAutoGenerated2, pipeline_response)
+ raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
+
+ return pipeline_response
+
+ return AsyncItemPaged(get_next, extract_data)
- return deserialized
+ @distributed_trace_async
+ async def get_enrichments(self, scope: str, alert_id: str, **kwargs: Any) -> _models.AlertEnrichmentResponse:
+ """Get the enrichments of an alert.
+
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
+ :param alert_id: Unique ID of an alert instance. Required.
+ :type alert_id: str
+ :return: AlertEnrichmentResponse or the result of cls(response)
+ :rtype: ~azure.mgmt.alertsmanagement.models.AlertEnrichmentResponse
+ :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", "2024-01-01-preview"))
+ cls: ClsType[_models.AlertEnrichmentResponse] = kwargs.pop("cls", None)
+
+ _request = build_get_enrichments_request(
+ scope=scope,
+ alert_id=alert_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.ErrorResponseAutoGenerated2, pipeline_response)
+ raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
+
+ deserialized = self._deserialize("AlertEnrichmentResponse", pipeline_response.http_response)
+
+ if cls:
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- get_summary.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alertsSummary"}
+ return deserialized # type: ignore
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_operations.py
index 16de0c0774897..7a68ac486f31a 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_operations.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_operations.py
@@ -1,4 +1,3 @@
-# pylint: disable=too-many-lines
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
@@ -19,20 +18,18 @@
map_error,
)
from azure.core.pipeline import PipelineResponse
-from azure.core.pipeline.transport import AsyncHttpResponse
-from azure.core.rest import HttpRequest
+from azure.core.rest import AsyncHttpResponse, HttpRequest
from azure.core.tracing.decorator import distributed_trace
from azure.core.utils import case_insensitive_dict
from azure.mgmt.core.exceptions import ARMErrorFormat
from ... import models as _models
-from ..._vendor import _convert_request
from ...operations._operations import build_list_request
-if sys.version_info >= (3, 8):
- from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports
+if sys.version_info >= (3, 9):
+ from collections.abc import MutableMapping
else:
- from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports
+ from typing import MutableMapping # type: ignore
T = TypeVar("T")
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]]
@@ -60,7 +57,6 @@ def __init__(self, *args, **kwargs) -> None:
def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]:
"""List all operations available through Azure Alerts Management Resource Provider.
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either Operation or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.alertsmanagement.models.Operation]
:raises ~azure.core.exceptions.HttpResponseError:
@@ -68,12 +64,10 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]:
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
cls: ClsType[_models.OperationsList] = kwargs.pop("cls", None)
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -84,21 +78,18 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]:
def prepare_request(next_link=None):
if not next_link:
- request = build_list_request(
+ _request = build_list_request(
api_version=api_version,
- template_url=self.list.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
else:
- request = HttpRequest("GET", next_link)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
- request.method = "GET"
- return request
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
async def extract_data(pipeline_response):
deserialized = self._deserialize("OperationsList", pipeline_response)
@@ -108,20 +99,19 @@ async def extract_data(pipeline_response):
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
- request = prepare_request(next_link)
+ _request = prepare_request(next_link)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated2, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
-
- list.metadata = {"url": "/providers/Microsoft.AlertsManagement/operations"}
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_prometheus_rule_groups_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_prometheus_rule_groups_operations.py
index a63d6eb5c3711..dee3ab8598b8a 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_prometheus_rule_groups_operations.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_prometheus_rule_groups_operations.py
@@ -1,4 +1,3 @@
-# pylint: disable=too-many-lines
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
@@ -6,6 +5,7 @@
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
+from io import IOBase
import sys
from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload
@@ -19,15 +19,13 @@
map_error,
)
from azure.core.pipeline import PipelineResponse
-from azure.core.pipeline.transport import AsyncHttpResponse
-from azure.core.rest import HttpRequest
+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 ..._vendor import _convert_request
from ...operations._prometheus_rule_groups_operations import (
build_create_or_update_request,
build_delete_request,
@@ -37,10 +35,10 @@
build_update_request,
)
-if sys.version_info >= (3, 8):
- from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports
+if sys.version_info >= (3, 9):
+ from collections.abc import MutableMapping
else:
- from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports
+ from typing import MutableMapping # type: ignore
T = TypeVar("T")
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]]
@@ -66,9 +64,8 @@ def __init__(self, *args, **kwargs) -> None:
@distributed_trace
def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.PrometheusRuleGroupResource"]:
- """Retrieve Prometheus rule group definitions in a subscription.
+ """Retrieve Prometheus all rule group definitions in a subscription.
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either PrometheusRuleGroupResource or the result of
cls(response)
:rtype:
@@ -78,12 +75,10 @@ def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.Promethe
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
cls: ClsType[_models.PrometheusRuleGroupResourceCollection] = kwargs.pop("cls", None)
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -94,22 +89,19 @@ def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.Promethe
def prepare_request(next_link=None):
if not next_link:
- request = build_list_by_subscription_request(
+ _request = build_list_by_subscription_request(
subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.list_by_subscription.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
else:
- request = HttpRequest("GET", next_link)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
- request.method = "GET"
- return request
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
async def extract_data(pipeline_response):
deserialized = self._deserialize("PrometheusRuleGroupResourceCollection", pipeline_response)
@@ -119,26 +111,23 @@ async def extract_data(pipeline_response):
return None, AsyncList(list_of_elem)
async def get_next(next_link=None):
- request = prepare_request(next_link)
+ _request = prepare_request(next_link)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated, pipeline_response)
+ 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)
- list_by_subscription.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/prometheusRuleGroups"
- }
-
@distributed_trace
def list_by_resource_group(
self, resource_group_name: str, **kwargs: Any
@@ -148,7 +137,6 @@ def list_by_resource_group(
:param resource_group_name: The name of the resource group. The name is case insensitive.
Required.
:type resource_group_name: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either PrometheusRuleGroupResource or the result of
cls(response)
:rtype:
@@ -158,12 +146,10 @@ def list_by_resource_group(
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
cls: ClsType[_models.PrometheusRuleGroupResourceCollection] = kwargs.pop("cls", None)
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -174,23 +160,20 @@ def list_by_resource_group(
def prepare_request(next_link=None):
if not next_link:
- request = build_list_by_resource_group_request(
+ _request = build_list_by_resource_group_request(
resource_group_name=resource_group_name,
subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.list_by_resource_group.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
else:
- request = HttpRequest("GET", next_link)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
- request.method = "GET"
- return request
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
async def extract_data(pipeline_response):
deserialized = self._deserialize("PrometheusRuleGroupResourceCollection", pipeline_response)
@@ -200,26 +183,23 @@ async def extract_data(pipeline_response):
return None, AsyncList(list_of_elem)
async def get_next(next_link=None):
- request = prepare_request(next_link)
+ _request = prepare_request(next_link)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated, pipeline_response)
+ 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)
- list_by_resource_group.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/prometheusRuleGroups"
- }
-
@distributed_trace_async
async def get(
self, resource_group_name: str, rule_group_name: str, **kwargs: Any
@@ -231,12 +211,11 @@ async def get(
:type resource_group_name: str
:param rule_group_name: The name of the rule group. Required.
:type rule_group_name: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: PrometheusRuleGroupResource or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -247,44 +226,37 @@ async def get(
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
cls: ClsType[_models.PrometheusRuleGroupResource] = kwargs.pop("cls", None)
- request = build_get_request(
+ _request = build_get_request(
resource_group_name=resource_group_name,
rule_group_name=rule_group_name,
subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.get.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("PrometheusRuleGroupResource", pipeline_response)
+ deserialized = self._deserialize("PrometheusRuleGroupResource", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
-
- return deserialized
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- get.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/prometheusRuleGroups/{ruleGroupName}"
- }
+ return deserialized # type: ignore
@overload
async def create_or_update(
@@ -308,7 +280,6 @@ async def create_or_update(
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: PrometheusRuleGroupResource or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource
:raises ~azure.core.exceptions.HttpResponseError:
@@ -319,7 +290,7 @@ async def create_or_update(
self,
resource_group_name: str,
rule_group_name: str,
- parameters: IO,
+ parameters: IO[bytes],
*,
content_type: str = "application/json",
**kwargs: Any
@@ -332,11 +303,10 @@ async def create_or_update(
:param rule_group_name: The name of the rule group. Required.
:type rule_group_name: str
:param parameters: The parameters of the rule group to create or update. Required.
- :type parameters: IO
+ :type parameters: IO[bytes]
:keyword content_type: Body Parameter content-type. Content type parameter for binary body.
Default value is "application/json".
:paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: PrometheusRuleGroupResource or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource
:raises ~azure.core.exceptions.HttpResponseError:
@@ -347,7 +317,7 @@ async def create_or_update(
self,
resource_group_name: str,
rule_group_name: str,
- parameters: Union[_models.PrometheusRuleGroupResource, IO],
+ parameters: Union[_models.PrometheusRuleGroupResource, IO[bytes]],
**kwargs: Any
) -> _models.PrometheusRuleGroupResource:
"""Create or update a Prometheus rule group definition.
@@ -357,18 +327,14 @@ async def create_or_update(
:type resource_group_name: str
:param rule_group_name: The name of the rule group. Required.
:type rule_group_name: str
- :param parameters: The parameters of the rule group to create or update. Is either a model type
- or a IO type. Required.
- :type parameters: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource or IO
- :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
- Default value is None.
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
+ :param parameters: The parameters of the rule group to create or update. Is either a
+ PrometheusRuleGroupResource type or a IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource or IO[bytes]
:return: PrometheusRuleGroupResource or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -379,21 +345,19 @@ async def create_or_update(
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
cls: ClsType[_models.PrometheusRuleGroupResource] = kwargs.pop("cls", None)
content_type = content_type or "application/json"
_json = None
_content = None
- if isinstance(parameters, (IO, bytes)):
+ if isinstance(parameters, (IOBase, bytes)):
_content = parameters
else:
_json = self._serialize.body(parameters, "PrometheusRuleGroupResource")
- request = build_create_or_update_request(
+ _request = build_create_or_update_request(
resource_group_name=resource_group_name,
rule_group_name=rule_group_name,
subscription_id=self._config.subscription_id,
@@ -401,45 +365,36 @@ async def create_or_update(
content_type=content_type,
json=_json,
content=_content,
- template_url=self.create_or_update.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _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.ErrorResponseAutoGenerated, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- if response.status_code == 200:
- deserialized = self._deserialize("PrometheusRuleGroupResource", pipeline_response)
-
- if response.status_code == 201:
- deserialized = self._deserialize("PrometheusRuleGroupResource", pipeline_response)
+ deserialized = self._deserialize("PrometheusRuleGroupResource", pipeline_response.http_response)
if cls:
return cls(pipeline_response, deserialized, {}) # type: ignore
return deserialized # type: ignore
- create_or_update.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/prometheusRuleGroups/{ruleGroupName}"
- }
-
@overload
async def update(
self,
resource_group_name: str,
rule_group_name: str,
- parameters: _models.PrometheusRuleGroupResourcePatch,
+ parameters: _models.PrometheusRuleGroupResourcePatchParameters,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -452,11 +407,11 @@ async def update(
:param rule_group_name: The name of the rule group. Required.
:type rule_group_name: str
:param parameters: The parameters of the rule group to update. Required.
- :type parameters: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResourcePatch
+ :type parameters:
+ ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResourcePatchParameters
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: PrometheusRuleGroupResource or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource
:raises ~azure.core.exceptions.HttpResponseError:
@@ -467,7 +422,7 @@ async def update(
self,
resource_group_name: str,
rule_group_name: str,
- parameters: IO,
+ parameters: IO[bytes],
*,
content_type: str = "application/json",
**kwargs: Any
@@ -480,11 +435,10 @@ async def update(
:param rule_group_name: The name of the rule group. Required.
:type rule_group_name: str
:param parameters: The parameters of the rule group to update. Required.
- :type parameters: IO
+ :type parameters: IO[bytes]
:keyword content_type: Body Parameter content-type. Content type parameter for binary body.
Default value is "application/json".
:paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: PrometheusRuleGroupResource or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource
:raises ~azure.core.exceptions.HttpResponseError:
@@ -495,7 +449,7 @@ async def update(
self,
resource_group_name: str,
rule_group_name: str,
- parameters: Union[_models.PrometheusRuleGroupResourcePatch, IO],
+ parameters: Union[_models.PrometheusRuleGroupResourcePatchParameters, IO[bytes]],
**kwargs: Any
) -> _models.PrometheusRuleGroupResource:
"""Update an Prometheus rule group definition.
@@ -505,18 +459,15 @@ async def update(
:type resource_group_name: str
:param rule_group_name: The name of the rule group. Required.
:type rule_group_name: str
- :param parameters: The parameters of the rule group to update. Is either a model type or a IO
- type. Required.
- :type parameters: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResourcePatch or IO
- :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
- Default value is None.
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
+ :param parameters: The parameters of the rule group to update. Is either a
+ PrometheusRuleGroupResourcePatchParameters type or a IO[bytes] type. Required.
+ :type parameters:
+ ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResourcePatchParameters or IO[bytes]
:return: PrometheusRuleGroupResource or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -527,21 +478,19 @@ async def update(
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
cls: ClsType[_models.PrometheusRuleGroupResource] = kwargs.pop("cls", None)
content_type = content_type or "application/json"
_json = None
_content = None
- if isinstance(parameters, (IO, bytes)):
+ if isinstance(parameters, (IOBase, bytes)):
_content = parameters
else:
- _json = self._serialize.body(parameters, "PrometheusRuleGroupResourcePatch")
+ _json = self._serialize.body(parameters, "PrometheusRuleGroupResourcePatchParameters")
- request = build_update_request(
+ _request = build_update_request(
resource_group_name=resource_group_name,
rule_group_name=rule_group_name,
subscription_id=self._config.subscription_id,
@@ -549,39 +498,32 @@ async def update(
content_type=content_type,
json=_json,
content=_content,
- template_url=self.update.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("PrometheusRuleGroupResource", pipeline_response)
+ deserialized = self._deserialize("PrometheusRuleGroupResource", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
-
- return deserialized
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- update.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/prometheusRuleGroups/{ruleGroupName}"
- }
+ return deserialized # type: ignore
@distributed_trace_async
- async def delete( # pylint: disable=inconsistent-return-statements
- self, resource_group_name: str, rule_group_name: str, **kwargs: Any
- ) -> None:
+ async def delete(self, resource_group_name: str, rule_group_name: str, **kwargs: Any) -> None:
"""Delete a Prometheus rule group definition.
:param resource_group_name: The name of the resource group. The name is case insensitive.
@@ -589,12 +531,11 @@ async def delete( # pylint: disable=inconsistent-return-statements
:type resource_group_name: str
:param rule_group_name: The name of the rule group. Required.
:type rule_group_name: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: None or the result of cls(response)
:rtype: None
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -605,37 +546,30 @@ async def delete( # pylint: disable=inconsistent-return-statements
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
cls: ClsType[None] = kwargs.pop("cls", None)
- request = build_delete_request(
+ _request = build_delete_request(
resource_group_name=resource_group_name,
rule_group_name=rule_group_name,
subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.delete.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _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.ErrorResponseAutoGenerated, pipeline_response)
+ 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, {})
-
- delete.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/prometheusRuleGroups/{ruleGroupName}"
- }
+ return cls(pipeline_response, None, {}) # type: ignore
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_smart_groups_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_smart_groups_operations.py
index e1efa45723372..7bc1226cf5432 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_smart_groups_operations.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/aio/operations/_smart_groups_operations.py
@@ -1,4 +1,3 @@
-# pylint: disable=too-many-lines
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
@@ -19,15 +18,13 @@
map_error,
)
from azure.core.pipeline import PipelineResponse
-from azure.core.pipeline.transport import AsyncHttpResponse
-from azure.core.rest import HttpRequest
+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 ..._vendor import _convert_request
from ...operations._smart_groups_operations import (
build_change_state_request,
build_get_all_request,
@@ -35,10 +32,10 @@
build_get_history_request,
)
-if sys.version_info >= (3, 8):
- from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports
+if sys.version_info >= (3, 9):
+ from collections.abc import MutableMapping
else:
- from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports
+ from typing import MutableMapping # type: ignore
T = TypeVar("T")
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]]
@@ -95,7 +92,7 @@ def get_all(
value is select all. Known values are: "Application Insights", "ActivityLog Administrative",
"ActivityLog Security", "ActivityLog Recommendation", "ActivityLog Policy", "ActivityLog
Autoscale", "Log Analytics", "Nagios", "Platform", "SCOM", "ServiceHealth", "SmartDetector",
- "VM Insights", and "Zabbix". Default value is None.
+ "VM Insights", "Zabbix", and "Resource Health". Default value is None.
:type monitor_service: str or ~azure.mgmt.alertsmanagement.models.MonitorService
:param monitor_condition: Filter by monitor condition which is either 'Fired' or 'Resolved'.
Default value is to select all. Known values are: "Fired" and "Resolved". Default value is
@@ -122,7 +119,6 @@ def get_all(
value is 'desc' for time fields and 'asc' for others. Known values are: "asc" and "desc".
Default value is None.
:type sort_order: str or ~azure.mgmt.alertsmanagement.models.SortOrder
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either SmartGroup or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.alertsmanagement.models.SmartGroup]
:raises ~azure.core.exceptions.HttpResponseError:
@@ -130,12 +126,10 @@ def get_all(
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-05-05-preview"))
cls: ClsType[_models.SmartGroupsList] = kwargs.pop("cls", None)
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -146,7 +140,7 @@ def get_all(
def prepare_request(next_link=None):
if not next_link:
- request = build_get_all_request(
+ _request = build_get_all_request(
subscription_id=self._config.subscription_id,
target_resource=target_resource,
target_resource_group=target_resource_group,
@@ -160,19 +154,16 @@ def prepare_request(next_link=None):
sort_by=sort_by,
sort_order=sort_order,
api_version=api_version,
- template_url=self.get_all.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
else:
- request = HttpRequest("GET", next_link)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
- request.method = "GET"
- return request
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
async def extract_data(pipeline_response):
deserialized = self._deserialize("SmartGroupsList", pipeline_response)
@@ -182,10 +173,11 @@ async def extract_data(pipeline_response):
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
- request = prepare_request(next_link)
+ _request = prepare_request(next_link)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = pipeline_response.http_response
@@ -198,8 +190,6 @@ async def get_next(next_link=None):
return AsyncItemPaged(get_next, extract_data)
- get_all.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/smartGroups"}
-
@distributed_trace_async
async def get_by_id(self, smart_group_id: str, **kwargs: Any) -> _models.SmartGroup:
"""Get information related to a specific Smart Group.
@@ -208,12 +198,11 @@ async def get_by_id(self, smart_group_id: str, **kwargs: Any) -> _models.SmartGr
:param smart_group_id: Smart group unique id. Required.
:type smart_group_id: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: SmartGroup or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.SmartGroup
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -224,24 +213,21 @@ async def get_by_id(self, smart_group_id: str, **kwargs: Any) -> _models.SmartGr
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-05-05-preview"))
cls: ClsType[_models.SmartGroup] = kwargs.pop("cls", None)
- request = build_get_by_id_request(
+ _request = build_get_by_id_request(
smart_group_id=smart_group_id,
subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.get_by_id.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = pipeline_response.http_response
@@ -254,16 +240,12 @@ async def get_by_id(self, smart_group_id: str, **kwargs: Any) -> _models.SmartGr
response_headers = {}
response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
- deserialized = self._deserialize("SmartGroup", pipeline_response)
+ deserialized = self._deserialize("SmartGroup", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, response_headers)
-
- return deserialized
+ return cls(pipeline_response, deserialized, response_headers) # type: ignore
- get_by_id.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/smartGroups/{smartGroupId}"
- }
+ return deserialized # type: ignore
@distributed_trace_async
async def change_state(
@@ -276,12 +258,11 @@ async def change_state(
:param new_state: New state of the alert. Known values are: "New", "Acknowledged", and
"Closed". Required.
:type new_state: str or ~azure.mgmt.alertsmanagement.models.AlertState
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: SmartGroup or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.SmartGroup
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -292,25 +273,22 @@ async def change_state(
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-05-05-preview"))
cls: ClsType[_models.SmartGroup] = kwargs.pop("cls", None)
- request = build_change_state_request(
+ _request = build_change_state_request(
smart_group_id=smart_group_id,
subscription_id=self._config.subscription_id,
new_state=new_state,
api_version=api_version,
- template_url=self.change_state.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = pipeline_response.http_response
@@ -323,16 +301,12 @@ async def change_state(
response_headers = {}
response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
- deserialized = self._deserialize("SmartGroup", pipeline_response)
+ deserialized = self._deserialize("SmartGroup", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, response_headers)
-
- return deserialized
+ return cls(pipeline_response, deserialized, response_headers) # type: ignore
- change_state.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/smartGroups/{smartGroupId}/changeState"
- }
+ return deserialized # type: ignore
@distributed_trace_async
async def get_history(self, smart_group_id: str, **kwargs: Any) -> _models.SmartGroupModification:
@@ -341,12 +315,11 @@ async def get_history(self, smart_group_id: str, **kwargs: Any) -> _models.Smart
:param smart_group_id: Smart group unique id. Required.
:type smart_group_id: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: SmartGroupModification or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.SmartGroupModification
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -357,24 +330,21 @@ async def get_history(self, smart_group_id: str, **kwargs: Any) -> _models.Smart
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-05-05-preview"))
cls: ClsType[_models.SmartGroupModification] = kwargs.pop("cls", None)
- request = build_get_history_request(
+ _request = build_get_history_request(
smart_group_id=smart_group_id,
subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.get_history.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = pipeline_response.http_response
@@ -384,13 +354,9 @@ async def get_history(self, smart_group_id: str, **kwargs: Any) -> _models.Smart
error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated3, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("SmartGroupModification", pipeline_response)
+ deserialized = self._deserialize("SmartGroupModification", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
-
- return deserialized
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- get_history.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/smartGroups/{smartGroupId}/history"
- }
+ return deserialized # type: ignore
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/models/__init__.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/models/__init__.py
index 1bea22079797c..f174746779199 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/models/__init__.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/models/__init__.py
@@ -5,104 +5,112 @@
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
+# pylint: disable=wrong-import-position
-from ._models_py3 import Action
-from ._models_py3 import ActionStatus
-from ._models_py3 import AddActionGroups
-from ._models_py3 import Alert
-from ._models_py3 import AlertModification
-from ._models_py3 import AlertModificationItem
-from ._models_py3 import AlertModificationProperties
-from ._models_py3 import AlertProcessingRule
-from ._models_py3 import AlertProcessingRuleProperties
-from ._models_py3 import AlertProcessingRulesList
-from ._models_py3 import AlertProperties
-from ._models_py3 import AlertsList
-from ._models_py3 import AlertsMetaData
-from ._models_py3 import AlertsMetaDataProperties
-from ._models_py3 import AlertsSummary
-from ._models_py3 import AlertsSummaryGroup
-from ._models_py3 import AlertsSummaryGroupItem
-from ._models_py3 import Comments
-from ._models_py3 import Condition
-from ._models_py3 import DailyRecurrence
-from ._models_py3 import ErrorAdditionalInfo
-from ._models_py3 import ErrorDetail
-from ._models_py3 import ErrorResponse
-from ._models_py3 import ErrorResponseAutoGenerated
-from ._models_py3 import ErrorResponseAutoGenerated2
-from ._models_py3 import ErrorResponseAutoGenerated3
-from ._models_py3 import ErrorResponseBody
-from ._models_py3 import ErrorResponseBodyAutoGenerated
-from ._models_py3 import ErrorResponseBodyAutoGenerated2
-from ._models_py3 import Essentials
-from ._models_py3 import ManagedResource
-from ._models_py3 import MonitorServiceDetails
-from ._models_py3 import MonitorServiceList
-from ._models_py3 import MonthlyRecurrence
-from ._models_py3 import Operation
-from ._models_py3 import OperationDisplay
-from ._models_py3 import OperationsList
-from ._models_py3 import PatchObject
-from ._models_py3 import PrometheusRule
-from ._models_py3 import PrometheusRuleGroupAction
-from ._models_py3 import PrometheusRuleGroupResource
-from ._models_py3 import PrometheusRuleGroupResourceCollection
-from ._models_py3 import PrometheusRuleGroupResourcePatch
-from ._models_py3 import PrometheusRuleGroupResourcePatchProperties
-from ._models_py3 import PrometheusRuleResolveConfiguration
-from ._models_py3 import Recurrence
-from ._models_py3 import RemoveAllActionGroups
-from ._models_py3 import Resource
-from ._models_py3 import ResourceAutoGenerated
-from ._models_py3 import Schedule
-from ._models_py3 import SmartGroup
-from ._models_py3 import SmartGroupAggregatedProperty
-from ._models_py3 import SmartGroupModification
-from ._models_py3 import SmartGroupModificationItem
-from ._models_py3 import SmartGroupModificationProperties
-from ._models_py3 import SmartGroupsList
-from ._models_py3 import SystemData
-from ._models_py3 import TrackedResource
-from ._models_py3 import WeeklyRecurrence
+from typing import TYPE_CHECKING
-from ._alerts_management_client_enums import ActionType
-from ._alerts_management_client_enums import AlertModificationEvent
-from ._alerts_management_client_enums import AlertState
-from ._alerts_management_client_enums import AlertsSortByFields
-from ._alerts_management_client_enums import AlertsSummaryGroupByFields
-from ._alerts_management_client_enums import CreatedByType
-from ._alerts_management_client_enums import DaysOfWeek
-from ._alerts_management_client_enums import Field
-from ._alerts_management_client_enums import Identifier
-from ._alerts_management_client_enums import MetadataIdentifier
-from ._alerts_management_client_enums import MonitorCondition
-from ._alerts_management_client_enums import MonitorService
-from ._alerts_management_client_enums import Operator
-from ._alerts_management_client_enums import RecurrenceType
-from ._alerts_management_client_enums import Severity
-from ._alerts_management_client_enums import SignalType
-from ._alerts_management_client_enums import SmartGroupModificationEvent
-from ._alerts_management_client_enums import SmartGroupsSortByFields
-from ._alerts_management_client_enums import SortOrder
-from ._alerts_management_client_enums import State
-from ._alerts_management_client_enums import TimeRange
+if TYPE_CHECKING:
+ from ._patch import * # pylint: disable=unused-wildcard-import
+
+
+from ._models_py3 import ( # type: ignore
+ ActionStatus,
+ Alert,
+ AlertEnrichmentItem,
+ AlertEnrichmentProperties,
+ AlertEnrichmentResponse,
+ AlertEnrichmentsList,
+ AlertModification,
+ AlertModificationItem,
+ AlertModificationProperties,
+ AlertProperties,
+ AlertRuleRecommendationResource,
+ AlertRuleRecommendationsListResponse,
+ AlertsList,
+ AlertsMetaData,
+ AlertsMetaDataProperties,
+ AlertsSummary,
+ AlertsSummaryGroup,
+ AlertsSummaryGroupItem,
+ Comments,
+ CorrelationDetails,
+ ErrorAdditionalInfo,
+ ErrorDetail,
+ ErrorDetailAutoGenerated,
+ ErrorResponse,
+ ErrorResponseAutoGenerated,
+ ErrorResponseAutoGenerated2,
+ ErrorResponseAutoGenerated3,
+ ErrorResponseBody,
+ ErrorResponseBodyAutoGenerated,
+ Essentials,
+ MonitorServiceDetails,
+ MonitorServiceList,
+ Operation,
+ OperationDisplay,
+ OperationsList,
+ PrometheusEnrichmentItem,
+ PrometheusInstantQuery,
+ PrometheusRangeQuery,
+ PrometheusRule,
+ PrometheusRuleGroupAction,
+ PrometheusRuleGroupResource,
+ PrometheusRuleGroupResourceCollection,
+ PrometheusRuleGroupResourcePatchParameters,
+ PrometheusRuleResolveConfiguration,
+ ProxyResource,
+ Resource,
+ ResourceAutoGenerated,
+ ResourceAutoGenerated2,
+ RuleArmTemplate,
+ SmartGroup,
+ SmartGroupAggregatedProperty,
+ SmartGroupModification,
+ SmartGroupModificationItem,
+ SmartGroupModificationProperties,
+ SmartGroupsList,
+ SystemData,
+ TrackedResource,
+)
+
+from ._alerts_management_client_enums import ( # type: ignore
+ AlertModificationEvent,
+ AlertState,
+ AlertsSortByFields,
+ AlertsSummaryGroupByFields,
+ CreatedByType,
+ Identifier,
+ MetadataIdentifier,
+ MetricAlertsDisplayUnit,
+ MonitorCondition,
+ MonitorService,
+ Severity,
+ SignalType,
+ SmartGroupModificationEvent,
+ SmartGroupsSortByFields,
+ SortOrder,
+ State,
+ Status,
+ TimeRange,
+ Type,
+)
from ._patch import __all__ as _patch_all
-from ._patch import * # pylint: disable=unused-wildcard-import
+from ._patch import *
from ._patch import patch_sdk as _patch_sdk
__all__ = [
- "Action",
"ActionStatus",
- "AddActionGroups",
"Alert",
+ "AlertEnrichmentItem",
+ "AlertEnrichmentProperties",
+ "AlertEnrichmentResponse",
+ "AlertEnrichmentsList",
"AlertModification",
"AlertModificationItem",
"AlertModificationProperties",
- "AlertProcessingRule",
- "AlertProcessingRuleProperties",
- "AlertProcessingRulesList",
"AlertProperties",
+ "AlertRuleRecommendationResource",
+ "AlertRuleRecommendationsListResponse",
"AlertsList",
"AlertsMetaData",
"AlertsMetaDataProperties",
@@ -110,38 +118,36 @@
"AlertsSummaryGroup",
"AlertsSummaryGroupItem",
"Comments",
- "Condition",
- "DailyRecurrence",
+ "CorrelationDetails",
"ErrorAdditionalInfo",
"ErrorDetail",
+ "ErrorDetailAutoGenerated",
"ErrorResponse",
"ErrorResponseAutoGenerated",
"ErrorResponseAutoGenerated2",
"ErrorResponseAutoGenerated3",
"ErrorResponseBody",
"ErrorResponseBodyAutoGenerated",
- "ErrorResponseBodyAutoGenerated2",
"Essentials",
- "ManagedResource",
"MonitorServiceDetails",
"MonitorServiceList",
- "MonthlyRecurrence",
"Operation",
"OperationDisplay",
"OperationsList",
- "PatchObject",
+ "PrometheusEnrichmentItem",
+ "PrometheusInstantQuery",
+ "PrometheusRangeQuery",
"PrometheusRule",
"PrometheusRuleGroupAction",
"PrometheusRuleGroupResource",
"PrometheusRuleGroupResourceCollection",
- "PrometheusRuleGroupResourcePatch",
- "PrometheusRuleGroupResourcePatchProperties",
+ "PrometheusRuleGroupResourcePatchParameters",
"PrometheusRuleResolveConfiguration",
- "Recurrence",
- "RemoveAllActionGroups",
+ "ProxyResource",
"Resource",
"ResourceAutoGenerated",
- "Schedule",
+ "ResourceAutoGenerated2",
+ "RuleArmTemplate",
"SmartGroup",
"SmartGroupAggregatedProperty",
"SmartGroupModification",
@@ -150,28 +156,25 @@
"SmartGroupsList",
"SystemData",
"TrackedResource",
- "WeeklyRecurrence",
- "ActionType",
"AlertModificationEvent",
"AlertState",
"AlertsSortByFields",
"AlertsSummaryGroupByFields",
"CreatedByType",
- "DaysOfWeek",
- "Field",
"Identifier",
"MetadataIdentifier",
+ "MetricAlertsDisplayUnit",
"MonitorCondition",
"MonitorService",
- "Operator",
- "RecurrenceType",
"Severity",
"SignalType",
"SmartGroupModificationEvent",
"SmartGroupsSortByFields",
"SortOrder",
"State",
+ "Status",
"TimeRange",
+ "Type",
]
-__all__.extend([p for p in _patch_all if p not in __all__])
+__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore
_patch_sdk()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/models/_alerts_management_client_enums.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/models/_alerts_management_client_enums.py
index 845acc76887f4..e0ac2c98e72bf 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/models/_alerts_management_client_enums.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/models/_alerts_management_client_enums.py
@@ -10,13 +10,6 @@
from azure.core import CaseInsensitiveEnumMeta
-class ActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
- """Action that should be applied."""
-
- ADD_ACTION_GROUPS = "AddActionGroups"
- REMOVE_ALL_ACTION_GROUPS = "RemoveAllActionGroups"
-
-
class AlertModificationEvent(str, Enum, metaclass=CaseInsensitiveEnumMeta):
"""Reason for the modification."""
@@ -74,34 +67,6 @@ class CreatedByType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
KEY = "Key"
-class DaysOfWeek(str, Enum, metaclass=CaseInsensitiveEnumMeta):
- """Days of week."""
-
- SUNDAY = "Sunday"
- MONDAY = "Monday"
- TUESDAY = "Tuesday"
- WEDNESDAY = "Wednesday"
- THURSDAY = "Thursday"
- FRIDAY = "Friday"
- SATURDAY = "Saturday"
-
-
-class Field(str, Enum, metaclass=CaseInsensitiveEnumMeta):
- """Field for a given condition."""
-
- SEVERITY = "Severity"
- MONITOR_SERVICE = "MonitorService"
- MONITOR_CONDITION = "MonitorCondition"
- SIGNAL_TYPE = "SignalType"
- TARGET_RESOURCE_TYPE = "TargetResourceType"
- TARGET_RESOURCE = "TargetResource"
- TARGET_RESOURCE_GROUP = "TargetResourceGroup"
- ALERT_RULE_ID = "AlertRuleId"
- ALERT_RULE_NAME = "AlertRuleName"
- DESCRIPTION = "Description"
- ALERT_CONTEXT = "AlertContext"
-
-
class Identifier(str, Enum, metaclass=CaseInsensitiveEnumMeta):
"""Identifier."""
@@ -114,6 +79,47 @@ class MetadataIdentifier(str, Enum, metaclass=CaseInsensitiveEnumMeta):
MONITOR_SERVICE_LIST = "MonitorServiceList"
+class MetricAlertsDisplayUnit(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ """The unit to display for a metric alert rule."""
+
+ NONE = "None"
+ PERCENTAGE = "Percentage"
+ BYTES = "Bytes"
+ KILOBYTES = "Kilobytes"
+ MEGABYTES = "Megabytes"
+ GIGABYTES = "Gigabytes"
+ TERABYTES = "Terabytes"
+ PETABYTES = "Petabytes"
+ BYTES_PER_DAY = "BytesPerDay"
+ BYTES_PER_HOUR = "BytesPerHour"
+ BYTES_PER_MINUTE = "BytesPerMinute"
+ BYTES_PER_SECOND = "BytesPerSecond"
+ KILOBYTES_PER_SECOND = "KilobytesPerSecond"
+ MEGABYTES_PER_SECOND = "MegabytesPerSecond"
+ GIGABYTES_PER_SECOND = "GigabytesPerSecond"
+ TERABYTES_PER_SECOND = "TerabytesPerSecond"
+ PETABYTES_PER_SECOND = "PetabytesPerSecond"
+ COUNT = "Count"
+ THOUSAND = "Thousand"
+ MILLION = "Million"
+ BILLION = "Billion"
+ TRILLION = "Trillion"
+ MICRO_SECONDS = "MicroSeconds"
+ MILLI_SECONDS = "MilliSeconds"
+ SECONDS = "Seconds"
+ MINUTES = "Minutes"
+ HOURS = "Hours"
+ DAYS = "Days"
+ COUNT_PER_DAY = "CountPerDay"
+ COUNT_PER_HOUR = "CountPerHour"
+ COUNT_PER_MINUTE = "CountPerMinute"
+ COUNT_PER_SECOND = "CountPerSecond"
+ THOUSAND_PER_SECOND = "ThousandPerSecond"
+ MILLION_PER_SECOND = "MillionPerSecond"
+ BILLION_PER_SECOND = "BillionPerSecond"
+ TRILLION_PER_SECOND = "TrillionPerSecond"
+
+
class MonitorCondition(str, Enum, metaclass=CaseInsensitiveEnumMeta):
"""MonitorCondition."""
@@ -138,23 +144,7 @@ class MonitorService(str, Enum, metaclass=CaseInsensitiveEnumMeta):
SMART_DETECTOR = "SmartDetector"
VM_INSIGHTS = "VM Insights"
ZABBIX = "Zabbix"
-
-
-class Operator(str, Enum, metaclass=CaseInsensitiveEnumMeta):
- """Operator for a given condition."""
-
- EQUALS = "Equals"
- NOT_EQUALS = "NotEquals"
- CONTAINS = "Contains"
- DOES_NOT_CONTAIN = "DoesNotContain"
-
-
-class RecurrenceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
- """Specifies when the recurrence should be applied."""
-
- DAILY = "Daily"
- WEEKLY = "Weekly"
- MONTHLY = "Monthly"
+ RESOURCE_HEALTH = "Resource Health"
class Severity(str, Enum, metaclass=CaseInsensitiveEnumMeta):
@@ -209,6 +199,13 @@ class State(str, Enum, metaclass=CaseInsensitiveEnumMeta):
CLOSED = "Closed"
+class Status(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ """The status of the evaluation of the enrichment."""
+
+ SUCCEEDED = "Succeeded"
+ FAILED = "Failed"
+
+
class TimeRange(str, Enum, metaclass=CaseInsensitiveEnumMeta):
"""TimeRange."""
@@ -216,3 +213,10 @@ class TimeRange(str, Enum, metaclass=CaseInsensitiveEnumMeta):
ONE_D = "1d"
SEVEN_D = "7d"
THIRTY_D = "30d"
+
+
+class Type(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ """The enrichment type."""
+
+ PROMETHEUS_INSTANT_QUERY = "PrometheusInstantQuery"
+ PROMETHEUS_RANGE_QUERY = "PrometheusRangeQuery"
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/models/_models_py3.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/models/_models_py3.py
index de87aaa590fe4..55ac10600136e 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/models/_models_py3.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/models/_models_py3.py
@@ -1,5 +1,5 @@
-# coding=utf-8
# pylint: disable=too-many-lines
+# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
@@ -8,169 +8,326 @@
# --------------------------------------------------------------------------
import datetime
-from typing import Dict, List, Optional, TYPE_CHECKING, Union
+import sys
+from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union
from .. import _serialization
+if sys.version_info >= (3, 9):
+ from collections.abc import MutableMapping
+else:
+ from typing import MutableMapping # type: ignore
+
if TYPE_CHECKING:
- # pylint: disable=unused-import,ungrouped-imports
from .. import models as _models
+JSON = MutableMapping[str, Any] # pylint: disable=unsubscriptable-object
-class Action(_serialization.Model):
- """Action to be applied.
+class ActionStatus(_serialization.Model):
+ """Action status.
- You probably want to use the sub-classes and not this class directly. Known sub-classes are:
- AddActionGroups, RemoveAllActionGroups
+ :ivar is_suppressed: Value indicating whether alert is suppressed.
+ :vartype is_suppressed: bool
+ """
- All required parameters must be populated in order to send to Azure.
+ _attribute_map = {
+ "is_suppressed": {"key": "isSuppressed", "type": "bool"},
+ }
- :ivar action_type: Action that should be applied. Required. Known values are: "AddActionGroups"
- and "RemoveAllActionGroups".
- :vartype action_type: str or ~azure.mgmt.alertsmanagement.models.ActionType
+ def __init__(self, *, is_suppressed: Optional[bool] = None, **kwargs: Any) -> None:
+ """
+ :keyword is_suppressed: Value indicating whether alert is suppressed.
+ :paramtype is_suppressed: bool
+ """
+ super().__init__(**kwargs)
+ self.is_suppressed = is_suppressed
+
+
+class ResourceAutoGenerated(_serialization.Model):
+ """An azure resource object.
+
+ Variables are only populated by the server, and will be ignored when sending a request.
+
+ :ivar id: Azure resource Id.
+ :vartype id: str
+ :ivar type: Azure resource type.
+ :vartype type: str
+ :ivar name: Azure resource name.
+ :vartype name: str
"""
_validation = {
- "action_type": {"required": True},
+ "id": {"readonly": True},
+ "type": {"readonly": True},
+ "name": {"readonly": True},
}
_attribute_map = {
- "action_type": {"key": "actionType", "type": "str"},
- }
-
- _subtype_map = {
- "action_type": {"AddActionGroups": "AddActionGroups", "RemoveAllActionGroups": "RemoveAllActionGroups"}
+ "id": {"key": "id", "type": "str"},
+ "type": {"key": "type", "type": "str"},
+ "name": {"key": "name", "type": "str"},
}
- def __init__(self, **kwargs):
+ def __init__(self, **kwargs: Any) -> None:
""" """
super().__init__(**kwargs)
- self.action_type: Optional[str] = None
+ self.id = None
+ self.type = None
+ self.name = None
-class ActionStatus(_serialization.Model):
- """Action status.
+class Alert(ResourceAutoGenerated):
+ """An alert created in alert management service.
- :ivar is_suppressed: Value indicating whether alert is suppressed.
- :vartype is_suppressed: bool
+ Variables are only populated by the server, and will be ignored when sending a request.
+
+ :ivar id: Azure resource Id.
+ :vartype id: str
+ :ivar type: Azure resource type.
+ :vartype type: str
+ :ivar name: Azure resource name.
+ :vartype name: str
+ :ivar properties: Alert property bag.
+ :vartype properties: ~azure.mgmt.alertsmanagement.models.AlertProperties
"""
+ _validation = {
+ "id": {"readonly": True},
+ "type": {"readonly": True},
+ "name": {"readonly": True},
+ }
+
_attribute_map = {
- "is_suppressed": {"key": "isSuppressed", "type": "bool"},
+ "id": {"key": "id", "type": "str"},
+ "type": {"key": "type", "type": "str"},
+ "name": {"key": "name", "type": "str"},
+ "properties": {"key": "properties", "type": "AlertProperties"},
}
- def __init__(self, *, is_suppressed: Optional[bool] = None, **kwargs):
+ def __init__(self, *, properties: Optional["_models.AlertProperties"] = None, **kwargs: Any) -> None:
"""
- :keyword is_suppressed: Value indicating whether alert is suppressed.
- :paramtype is_suppressed: bool
+ :keyword properties: Alert property bag.
+ :paramtype properties: ~azure.mgmt.alertsmanagement.models.AlertProperties
"""
super().__init__(**kwargs)
- self.is_suppressed = is_suppressed
+ self.properties = properties
-class AddActionGroups(Action):
- """Add action groups to alert processing rule.
+class AlertEnrichmentItem(_serialization.Model):
+ """Alert enrichment item.
- All required parameters must be populated in order to send to Azure.
+ You probably want to use the sub-classes and not this class directly. Known sub-classes are:
+ PrometheusEnrichmentItem
+
+ All required parameters must be populated in order to send to server.
- :ivar action_type: Action that should be applied. Required. Known values are: "AddActionGroups"
- and "RemoveAllActionGroups".
- :vartype action_type: str or ~azure.mgmt.alertsmanagement.models.ActionType
- :ivar action_group_ids: List of action group Ids to add to alert processing rule. Required.
- :vartype action_group_ids: list[str]
+ :ivar title: The enrichment title. Required.
+ :vartype title: str
+ :ivar description: The enrichment description. Required.
+ :vartype description: str
+ :ivar status: The status of the evaluation of the enrichment. Required. Known values are:
+ "Succeeded" and "Failed".
+ :vartype status: str or ~azure.mgmt.alertsmanagement.models.Status
+ :ivar error_message: The error message. Will be present only if the status is 'Failed'.
+ :vartype error_message: str
+ :ivar type: The enrichment type. Required. Known values are: "PrometheusInstantQuery" and
+ "PrometheusRangeQuery".
+ :vartype type: str or ~azure.mgmt.alertsmanagement.models.Type
"""
_validation = {
- "action_type": {"required": True},
- "action_group_ids": {"required": True},
+ "title": {"required": True},
+ "description": {"required": True},
+ "status": {"required": True},
+ "type": {"required": True},
}
_attribute_map = {
- "action_type": {"key": "actionType", "type": "str"},
- "action_group_ids": {"key": "actionGroupIds", "type": "[str]"},
+ "title": {"key": "title", "type": "str"},
+ "description": {"key": "description", "type": "str"},
+ "status": {"key": "status", "type": "str"},
+ "error_message": {"key": "errorMessage", "type": "str"},
+ "type": {"key": "type", "type": "str"},
}
- def __init__(self, *, action_group_ids: List[str], **kwargs):
+ _subtype_map = {"type": {"PrometheusEnrichmentItem": "PrometheusEnrichmentItem"}}
+
+ def __init__(
+ self,
+ *,
+ title: str,
+ description: str,
+ status: Union[str, "_models.Status"],
+ error_message: Optional[str] = None,
+ **kwargs: Any
+ ) -> None:
+ """
+ :keyword title: The enrichment title. Required.
+ :paramtype title: str
+ :keyword description: The enrichment description. Required.
+ :paramtype description: str
+ :keyword status: The status of the evaluation of the enrichment. Required. Known values are:
+ "Succeeded" and "Failed".
+ :paramtype status: str or ~azure.mgmt.alertsmanagement.models.Status
+ :keyword error_message: The error message. Will be present only if the status is 'Failed'.
+ :paramtype error_message: str
+ """
+ super().__init__(**kwargs)
+ self.title = title
+ self.description = description
+ self.status = status
+ self.error_message = error_message
+ self.type: Optional[str] = None
+
+
+class AlertEnrichmentProperties(_serialization.Model):
+ """Properties of the alert enrichment item.
+
+ Variables are only populated by the server, and will be ignored when sending a request.
+
+ :ivar alert_id: Unique Id (GUID) of the alert for which the enrichments are being retrieved.
+ :vartype alert_id: str
+ :ivar enrichments: Enrichment details.
+ :vartype enrichments: list[~azure.mgmt.alertsmanagement.models.AlertEnrichmentItem]
+ """
+
+ _validation = {
+ "alert_id": {"readonly": True},
+ }
+
+ _attribute_map = {
+ "alert_id": {"key": "alertId", "type": "str"},
+ "enrichments": {"key": "enrichments", "type": "[AlertEnrichmentItem]"},
+ }
+
+ def __init__(self, *, enrichments: Optional[List["_models.AlertEnrichmentItem"]] = None, **kwargs: Any) -> None:
"""
- :keyword action_group_ids: List of action group Ids to add to alert processing rule. Required.
- :paramtype action_group_ids: list[str]
+ :keyword enrichments: Enrichment details.
+ :paramtype enrichments: list[~azure.mgmt.alertsmanagement.models.AlertEnrichmentItem]
"""
super().__init__(**kwargs)
- self.action_type: str = "AddActionGroups"
- self.action_group_ids = action_group_ids
+ self.alert_id = None
+ self.enrichments = enrichments
-class Resource(_serialization.Model):
- """An azure resource object.
+class ResourceAutoGenerated2(_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: Azure resource Id.
+ :ivar id: Fully qualified resource ID for the resource. E.g.
+ "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}". # pylint: disable=line-too-long
:vartype id: str
- :ivar type: Azure resource type.
- :vartype type: str
- :ivar name: Azure resource name.
+ :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.alertsmanagement.models.SystemData
"""
_validation = {
"id": {"readonly": True},
- "type": {"readonly": True},
"name": {"readonly": True},
+ "type": {"readonly": True},
+ "system_data": {"readonly": True},
}
_attribute_map = {
"id": {"key": "id", "type": "str"},
- "type": {"key": "type", "type": "str"},
"name": {"key": "name", "type": "str"},
+ "type": {"key": "type", "type": "str"},
+ "system_data": {"key": "systemData", "type": "SystemData"},
}
- def __init__(self, **kwargs):
+ def __init__(self, **kwargs: Any) -> None:
""" """
super().__init__(**kwargs)
self.id = None
- self.type = None
self.name = None
+ self.type = None
+ self.system_data = None
-class Alert(Resource):
- """An alert created in alert management service.
+class AlertEnrichmentResponse(ResourceAutoGenerated2):
+ """The alert's enrichments.
Variables are only populated by the server, and will be ignored when sending a request.
- :ivar id: Azure resource Id.
+ :ivar id: Fully qualified resource ID for the resource. E.g.
+ "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}". # pylint: disable=line-too-long
:vartype id: str
- :ivar type: Azure resource type.
- :vartype type: str
- :ivar name: Azure resource name.
+ :ivar name: The name of the resource.
:vartype name: str
- :ivar properties: Alert property bag.
- :vartype properties: ~azure.mgmt.alertsmanagement.models.AlertProperties
+ :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.alertsmanagement.models.SystemData
+ :ivar properties: Properties of the alert enrichment item.
+ :vartype properties: ~azure.mgmt.alertsmanagement.models.AlertEnrichmentProperties
"""
_validation = {
"id": {"readonly": True},
- "type": {"readonly": True},
"name": {"readonly": True},
+ "type": {"readonly": True},
+ "system_data": {"readonly": True},
}
_attribute_map = {
"id": {"key": "id", "type": "str"},
- "type": {"key": "type", "type": "str"},
"name": {"key": "name", "type": "str"},
- "properties": {"key": "properties", "type": "AlertProperties"},
+ "type": {"key": "type", "type": "str"},
+ "system_data": {"key": "systemData", "type": "SystemData"},
+ "properties": {"key": "properties", "type": "AlertEnrichmentProperties"},
}
- def __init__(self, *, properties: Optional["_models.AlertProperties"] = None, **kwargs):
+ def __init__(self, *, properties: Optional["_models.AlertEnrichmentProperties"] = None, **kwargs: Any) -> None:
"""
- :keyword properties: Alert property bag.
- :paramtype properties: ~azure.mgmt.alertsmanagement.models.AlertProperties
+ :keyword properties: Properties of the alert enrichment item.
+ :paramtype properties: ~azure.mgmt.alertsmanagement.models.AlertEnrichmentProperties
"""
super().__init__(**kwargs)
self.properties = properties
-class AlertModification(Resource):
+class AlertEnrichmentsList(_serialization.Model):
+ """List the alert's enrichments.
+
+ :ivar value: List the alert's enrichments.
+ :vartype value: list[~azure.mgmt.alertsmanagement.models.AlertEnrichmentResponse]
+ :ivar next_link: Request URL that can be used to query next page.
+ :vartype next_link: str
+ """
+
+ _attribute_map = {
+ "value": {"key": "value", "type": "[AlertEnrichmentResponse]"},
+ "next_link": {"key": "nextLink", "type": "str"},
+ }
+
+ def __init__(
+ self,
+ *,
+ value: Optional[List["_models.AlertEnrichmentResponse"]] = None,
+ next_link: Optional[str] = None,
+ **kwargs: Any
+ ) -> None:
+ """
+ :keyword value: List the alert's enrichments.
+ :paramtype value: list[~azure.mgmt.alertsmanagement.models.AlertEnrichmentResponse]
+ :keyword next_link: Request URL that can be used to query next page.
+ :paramtype next_link: str
+ """
+ super().__init__(**kwargs)
+ self.value = value
+ self.next_link = next_link
+
+
+class AlertModification(ResourceAutoGenerated):
"""Alert Modification details.
Variables are only populated by the server, and will be ignored when sending a request.
@@ -198,7 +355,7 @@ class AlertModification(Resource):
"properties": {"key": "properties", "type": "AlertModificationProperties"},
}
- def __init__(self, *, properties: Optional["_models.AlertModificationProperties"] = None, **kwargs):
+ def __init__(self, *, properties: Optional["_models.AlertModificationProperties"] = None, **kwargs: Any) -> None:
"""
:keyword properties: Properties of the alert modification item.
:paramtype properties: ~azure.mgmt.alertsmanagement.models.AlertModificationProperties
@@ -248,8 +405,8 @@ def __init__(
modified_by: Optional[str] = None,
comments: Optional[str] = None,
description: Optional[str] = None,
- **kwargs
- ):
+ **kwargs: Any
+ ) -> None:
"""
:keyword modification_event: Reason for the modification. Known values are: "AlertCreated",
"StateChange", "MonitorConditionChange", "SeverityChange", "ActionRuleTriggered",
@@ -299,7 +456,7 @@ class AlertModificationProperties(_serialization.Model):
"modifications": {"key": "modifications", "type": "[AlertModificationItem]"},
}
- def __init__(self, *, modifications: Optional[List["_models.AlertModificationItem"]] = None, **kwargs):
+ def __init__(self, *, modifications: Optional[List["_models.AlertModificationItem"]] = None, **kwargs: Any) -> None:
"""
:keyword modifications: Modification details.
:paramtype modifications: list[~azure.mgmt.alertsmanagement.models.AlertModificationItem]
@@ -309,243 +466,212 @@ def __init__(self, *, modifications: Optional[List["_models.AlertModificationIte
self.modifications = modifications
-class ManagedResource(Resource):
- """An azure managed resource object.
+class AlertProperties(_serialization.Model):
+ """Alert property bag.
Variables are only populated by the server, and will be ignored when sending a request.
- All required parameters must be populated in order to send to Azure.
-
- :ivar id: Azure resource Id.
- :vartype id: str
- :ivar type: Azure resource type.
- :vartype type: str
- :ivar name: Azure resource name.
- :vartype name: str
- :ivar location: Resource location. Required.
- :vartype location: str
- :ivar tags: Resource tags.
- :vartype tags: dict[str, str]
+ :ivar essentials: This object contains consistent fields across different monitor services.
+ :vartype essentials: ~azure.mgmt.alertsmanagement.models.Essentials
+ :ivar context: Information specific to the monitor service that gives more contextual details
+ about the alert.
+ :vartype context: JSON
+ :ivar egress_config: Config which would be used for displaying the data in portal.
+ :vartype egress_config: JSON
"""
_validation = {
- "id": {"readonly": True},
- "type": {"readonly": True},
- "name": {"readonly": True},
- "location": {"required": True},
+ "context": {"readonly": True},
+ "egress_config": {"readonly": True},
}
_attribute_map = {
- "id": {"key": "id", "type": "str"},
- "type": {"key": "type", "type": "str"},
- "name": {"key": "name", "type": "str"},
- "location": {"key": "location", "type": "str"},
- "tags": {"key": "tags", "type": "{str}"},
+ "essentials": {"key": "essentials", "type": "Essentials"},
+ "context": {"key": "context", "type": "object"},
+ "egress_config": {"key": "egressConfig", "type": "object"},
}
- def __init__(self, *, location: str, tags: Optional[Dict[str, str]] = None, **kwargs):
+ def __init__(self, *, essentials: Optional["_models.Essentials"] = None, **kwargs: Any) -> None:
"""
- :keyword location: Resource location. Required.
- :paramtype location: str
- :keyword tags: Resource tags.
- :paramtype tags: dict[str, str]
+ :keyword essentials: This object contains consistent fields across different monitor services.
+ :paramtype essentials: ~azure.mgmt.alertsmanagement.models.Essentials
"""
super().__init__(**kwargs)
- self.location = location
- self.tags = tags
+ self.essentials = essentials
+ self.context = None
+ self.egress_config = None
-class AlertProcessingRule(ManagedResource):
- """Alert processing rule object containing target scopes, conditions and scheduling logic.
+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.
- All required parameters must be populated in order to send to Azure.
-
- :ivar id: Azure resource Id.
+ :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 type: Azure resource type.
- :vartype type: str
- :ivar name: Azure resource name.
+ :ivar name: The name of the resource.
:vartype name: str
- :ivar location: Resource location. Required.
- :vartype location: str
- :ivar tags: Resource tags.
- :vartype tags: dict[str, str]
- :ivar properties: Alert processing rule properties.
- :vartype properties: ~azure.mgmt.alertsmanagement.models.AlertProcessingRuleProperties
- :ivar system_data: Alert processing rule system data.
+ :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.alertsmanagement.models.SystemData
"""
_validation = {
"id": {"readonly": True},
- "type": {"readonly": True},
"name": {"readonly": True},
- "location": {"required": True},
+ "type": {"readonly": True},
"system_data": {"readonly": True},
}
_attribute_map = {
"id": {"key": "id", "type": "str"},
- "type": {"key": "type", "type": "str"},
"name": {"key": "name", "type": "str"},
- "location": {"key": "location", "type": "str"},
- "tags": {"key": "tags", "type": "{str}"},
- "properties": {"key": "properties", "type": "AlertProcessingRuleProperties"},
+ "type": {"key": "type", "type": "str"},
"system_data": {"key": "systemData", "type": "SystemData"},
}
- def __init__(
- self,
- *,
- location: str,
- tags: Optional[Dict[str, str]] = None,
- properties: Optional["_models.AlertProcessingRuleProperties"] = None,
- **kwargs
- ):
- """
- :keyword location: Resource location. Required.
- :paramtype location: str
- :keyword tags: Resource tags.
- :paramtype tags: dict[str, str]
- :keyword properties: Alert processing rule properties.
- :paramtype properties: ~azure.mgmt.alertsmanagement.models.AlertProcessingRuleProperties
- """
- super().__init__(location=location, tags=tags, **kwargs)
- self.properties = properties
+ def __init__(self, **kwargs: Any) -> None:
+ """ """
+ super().__init__(**kwargs)
+ self.id = None
+ self.name = None
+ self.type = None
self.system_data = None
-class AlertProcessingRuleProperties(_serialization.Model):
- """Alert processing rule properties defining scopes, conditions and scheduling logic for alert processing rule.
+class ProxyResource(Resource):
+ """The resource model definition for a Azure Resource Manager proxy resource. It will not have
+ tags and a location.
- All required parameters must be populated in order to send to Azure.
+ Variables are only populated by the server, and will be ignored when sending a request.
- :ivar scopes: Scopes on which alert processing rule will apply. Required.
- :vartype scopes: list[str]
- :ivar conditions: Conditions on which alerts will be filtered.
- :vartype conditions: list[~azure.mgmt.alertsmanagement.models.Condition]
- :ivar schedule: Scheduling for alert processing rule.
- :vartype schedule: ~azure.mgmt.alertsmanagement.models.Schedule
- :ivar actions: Actions to be applied. Required.
- :vartype actions: list[~azure.mgmt.alertsmanagement.models.Action]
- :ivar description: Description of alert processing rule.
- :vartype description: str
- :ivar enabled: Indicates if the given alert processing rule is enabled or disabled.
- :vartype enabled: bool
+ :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.alertsmanagement.models.SystemData
"""
- _validation = {
- "scopes": {"required": True},
- "actions": {"required": True},
- }
- _attribute_map = {
- "scopes": {"key": "scopes", "type": "[str]"},
- "conditions": {"key": "conditions", "type": "[Condition]"},
- "schedule": {"key": "schedule", "type": "Schedule"},
- "actions": {"key": "actions", "type": "[Action]"},
- "description": {"key": "description", "type": "str"},
- "enabled": {"key": "enabled", "type": "bool"},
- }
-
- def __init__(
- self,
- *,
- scopes: List[str],
- actions: List["_models.Action"],
- conditions: Optional[List["_models.Condition"]] = None,
- schedule: Optional["_models.Schedule"] = None,
- description: Optional[str] = None,
- enabled: bool = True,
- **kwargs
- ):
- """
- :keyword scopes: Scopes on which alert processing rule will apply. Required.
- :paramtype scopes: list[str]
- :keyword conditions: Conditions on which alerts will be filtered.
- :paramtype conditions: list[~azure.mgmt.alertsmanagement.models.Condition]
- :keyword schedule: Scheduling for alert processing rule.
- :paramtype schedule: ~azure.mgmt.alertsmanagement.models.Schedule
- :keyword actions: Actions to be applied. Required.
- :paramtype actions: list[~azure.mgmt.alertsmanagement.models.Action]
- :keyword description: Description of alert processing rule.
- :paramtype description: str
- :keyword enabled: Indicates if the given alert processing rule is enabled or disabled.
- :paramtype enabled: bool
- """
- super().__init__(**kwargs)
- self.scopes = scopes
- self.conditions = conditions
- self.schedule = schedule
- self.actions = actions
- self.description = description
- self.enabled = enabled
+class AlertRuleRecommendationResource(ProxyResource):
+ """A single alert rule recommendation resource.
+ Variables are only populated by the server, and will be ignored when sending a request.
-class AlertProcessingRulesList(_serialization.Model):
- """List of alert processing rules.
+ All required parameters must be populated in order to send to server.
- :ivar next_link: URL to fetch the next set of alert processing rules.
- :vartype next_link: str
- :ivar value: List of alert processing rules.
- :vartype value: list[~azure.mgmt.alertsmanagement.models.AlertProcessingRule]
+ :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.alertsmanagement.models.SystemData
+ :ivar alert_rule_type: The recommendation alert rule type. Required.
+ :vartype alert_rule_type: str
+ :ivar category: The recommendation alert rule category.
+ :vartype category: str
+ :ivar display_information: A dictionary that provides the display information for an alert rule
+ recommendation. Required.
+ :vartype display_information: dict[str, str]
+ :ivar rule_arm_template: A complete ARM template to deploy the alert rules. Required.
+ :vartype rule_arm_template: ~azure.mgmt.alertsmanagement.models.RuleArmTemplate
"""
+ _validation = {
+ "id": {"readonly": True},
+ "name": {"readonly": True},
+ "type": {"readonly": True},
+ "system_data": {"readonly": True},
+ "alert_rule_type": {"required": True},
+ "display_information": {"required": True},
+ "rule_arm_template": {"required": True},
+ }
+
_attribute_map = {
- "next_link": {"key": "nextLink", "type": "str"},
- "value": {"key": "value", "type": "[AlertProcessingRule]"},
+ "id": {"key": "id", "type": "str"},
+ "name": {"key": "name", "type": "str"},
+ "type": {"key": "type", "type": "str"},
+ "system_data": {"key": "systemData", "type": "SystemData"},
+ "alert_rule_type": {"key": "properties.alertRuleType", "type": "str"},
+ "category": {"key": "properties.category", "type": "str"},
+ "display_information": {"key": "properties.displayInformation", "type": "{str}"},
+ "rule_arm_template": {"key": "properties.ruleArmTemplate", "type": "RuleArmTemplate"},
}
def __init__(
- self, *, next_link: Optional[str] = None, value: Optional[List["_models.AlertProcessingRule"]] = None, **kwargs
- ):
- """
- :keyword next_link: URL to fetch the next set of alert processing rules.
- :paramtype next_link: str
- :keyword value: List of alert processing rules.
- :paramtype value: list[~azure.mgmt.alertsmanagement.models.AlertProcessingRule]
+ self,
+ *,
+ alert_rule_type: str,
+ display_information: Dict[str, str],
+ rule_arm_template: "_models.RuleArmTemplate",
+ category: Optional[str] = None,
+ **kwargs: Any
+ ) -> None:
+ """
+ :keyword alert_rule_type: The recommendation alert rule type. Required.
+ :paramtype alert_rule_type: str
+ :keyword category: The recommendation alert rule category.
+ :paramtype category: str
+ :keyword display_information: A dictionary that provides the display information for an alert
+ rule recommendation. Required.
+ :paramtype display_information: dict[str, str]
+ :keyword rule_arm_template: A complete ARM template to deploy the alert rules. Required.
+ :paramtype rule_arm_template: ~azure.mgmt.alertsmanagement.models.RuleArmTemplate
"""
super().__init__(**kwargs)
- self.next_link = next_link
- self.value = value
+ self.alert_rule_type = alert_rule_type
+ self.category = category
+ self.display_information = display_information
+ self.rule_arm_template = rule_arm_template
-class AlertProperties(_serialization.Model):
- """Alert property bag.
+class AlertRuleRecommendationsListResponse(_serialization.Model):
+ """List of alert rule recommendations.
- 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 essentials: This object contains consistent fields across different monitor services.
- :vartype essentials: ~azure.mgmt.alertsmanagement.models.Essentials
- :ivar context: Information specific to the monitor service that gives more contextual details
- about the alert.
- :vartype context: JSON
- :ivar egress_config: Config which would be used for displaying the data in portal.
- :vartype egress_config: JSON
+ :ivar value: the values for the alert rule recommendations. Required.
+ :vartype value: list[~azure.mgmt.alertsmanagement.models.AlertRuleRecommendationResource]
+ :ivar next_link: URL to fetch the next set of recommendations.
+ :vartype next_link: str
"""
_validation = {
- "context": {"readonly": True},
- "egress_config": {"readonly": True},
+ "value": {"required": True},
}
_attribute_map = {
- "essentials": {"key": "essentials", "type": "Essentials"},
- "context": {"key": "context", "type": "object"},
- "egress_config": {"key": "egressConfig", "type": "object"},
+ "value": {"key": "value", "type": "[AlertRuleRecommendationResource]"},
+ "next_link": {"key": "nextLink", "type": "str"},
}
- def __init__(self, *, essentials: Optional["_models.Essentials"] = None, **kwargs):
+ def __init__(
+ self, *, value: List["_models.AlertRuleRecommendationResource"], next_link: Optional[str] = None, **kwargs: Any
+ ) -> None:
"""
- :keyword essentials: This object contains consistent fields across different monitor services.
- :paramtype essentials: ~azure.mgmt.alertsmanagement.models.Essentials
+ :keyword value: the values for the alert rule recommendations. Required.
+ :paramtype value: list[~azure.mgmt.alertsmanagement.models.AlertRuleRecommendationResource]
+ :keyword next_link: URL to fetch the next set of recommendations.
+ :paramtype next_link: str
"""
super().__init__(**kwargs)
- self.essentials = essentials
- self.context = None
- self.egress_config = None
+ self.value = value
+ self.next_link = next_link
class AlertsList(_serialization.Model):
@@ -562,7 +688,9 @@ class AlertsList(_serialization.Model):
"value": {"key": "value", "type": "[Alert]"},
}
- def __init__(self, *, next_link: Optional[str] = None, value: Optional[List["_models.Alert"]] = None, **kwargs):
+ def __init__(
+ self, *, next_link: Optional[str] = None, value: Optional[List["_models.Alert"]] = None, **kwargs: Any
+ ) -> None:
"""
:keyword next_link: URL to fetch the next set of alerts.
:paramtype next_link: str
@@ -585,7 +713,7 @@ class AlertsMetaData(_serialization.Model):
"properties": {"key": "properties", "type": "AlertsMetaDataProperties"},
}
- def __init__(self, *, properties: Optional["_models.AlertsMetaDataProperties"] = None, **kwargs):
+ def __init__(self, *, properties: Optional["_models.AlertsMetaDataProperties"] = None, **kwargs: Any) -> None:
"""
:keyword properties: alert meta data property bag.
:paramtype properties: ~azure.mgmt.alertsmanagement.models.AlertsMetaDataProperties
@@ -600,7 +728,7 @@ class AlertsMetaDataProperties(_serialization.Model):
You probably want to use the sub-classes and not this class directly. Known sub-classes are:
MonitorServiceList
- All required parameters must be populated in order to send to Azure.
+ All required parameters must be populated in order to send to server.
:ivar metadata_identifier: Identification of the information to be retrieved by API call.
Required. "MonitorServiceList"
@@ -617,13 +745,13 @@ class AlertsMetaDataProperties(_serialization.Model):
_subtype_map = {"metadata_identifier": {"MonitorServiceList": "MonitorServiceList"}}
- def __init__(self, **kwargs):
+ def __init__(self, **kwargs: Any) -> None:
""" """
super().__init__(**kwargs)
self.metadata_identifier: Optional[str] = None
-class AlertsSummary(Resource):
+class AlertsSummary(ResourceAutoGenerated):
"""Summary of alerts based on the input filters and 'groupby' parameters.
Variables are only populated by the server, and will be ignored when sending a request.
@@ -651,7 +779,7 @@ class AlertsSummary(Resource):
"properties": {"key": "properties", "type": "AlertsSummaryGroup"},
}
- def __init__(self, *, properties: Optional["_models.AlertsSummaryGroup"] = None, **kwargs):
+ def __init__(self, *, properties: Optional["_models.AlertsSummaryGroup"] = None, **kwargs: Any) -> None:
"""
:keyword properties: Group the result set.
:paramtype properties: ~azure.mgmt.alertsmanagement.models.AlertsSummaryGroup
@@ -687,8 +815,8 @@ def __init__(
smart_groups_count: Optional[int] = None,
groupedby: Optional[str] = None,
values: Optional[List["_models.AlertsSummaryGroupItem"]] = None,
- **kwargs
- ):
+ **kwargs: Any
+ ) -> None:
"""
:keyword total: Total count of the result set.
:paramtype total: int
@@ -733,8 +861,8 @@ def __init__(
count: Optional[int] = None,
groupedby: Optional[str] = None,
values: Optional[List["_models.AlertsSummaryGroupItem"]] = None,
- **kwargs
- ):
+ **kwargs: Any
+ ) -> None:
"""
:keyword name: Value of the aggregated field.
:paramtype name: str
@@ -763,7 +891,7 @@ class Comments(_serialization.Model):
"comments": {"key": "comments", "type": "str"},
}
- def __init__(self, *, comments: Optional[str] = None, **kwargs):
+ def __init__(self, *, comments: Optional[str] = None, **kwargs: Any) -> None:
"""
:keyword comments:
:paramtype comments: str
@@ -772,128 +900,38 @@ def __init__(self, *, comments: Optional[str] = None, **kwargs):
self.comments = comments
-class Condition(_serialization.Model):
- """Condition to trigger an alert processing rule.
-
- :ivar field: Field for a given condition. Known values are: "Severity", "MonitorService",
- "MonitorCondition", "SignalType", "TargetResourceType", "TargetResource",
- "TargetResourceGroup", "AlertRuleId", "AlertRuleName", "Description", and "AlertContext".
- :vartype field: str or ~azure.mgmt.alertsmanagement.models.Field
- :ivar operator: Operator for a given condition. Known values are: "Equals", "NotEquals",
- "Contains", and "DoesNotContain".
- :vartype operator: str or ~azure.mgmt.alertsmanagement.models.Operator
- :ivar values: List of values to match for a given condition.
- :vartype values: list[str]
- """
-
- _attribute_map = {
- "field": {"key": "field", "type": "str"},
- "operator": {"key": "operator", "type": "str"},
- "values": {"key": "values", "type": "[str]"},
- }
-
- def __init__(
- self,
- *,
- field: Optional[Union[str, "_models.Field"]] = None,
- operator: Optional[Union[str, "_models.Operator"]] = None,
- values: Optional[List[str]] = None,
- **kwargs
- ):
- """
- :keyword field: Field for a given condition. Known values are: "Severity", "MonitorService",
- "MonitorCondition", "SignalType", "TargetResourceType", "TargetResource",
- "TargetResourceGroup", "AlertRuleId", "AlertRuleName", "Description", and "AlertContext".
- :paramtype field: str or ~azure.mgmt.alertsmanagement.models.Field
- :keyword operator: Operator for a given condition. Known values are: "Equals", "NotEquals",
- "Contains", and "DoesNotContain".
- :paramtype operator: str or ~azure.mgmt.alertsmanagement.models.Operator
- :keyword values: List of values to match for a given condition.
- :paramtype values: list[str]
- """
- super().__init__(**kwargs)
- self.field = field
- self.operator = operator
- self.values = values
-
-
-class Recurrence(_serialization.Model):
- """Recurrence object.
+class CorrelationDetails(_serialization.Model):
+ """Correlation details.
- You probably want to use the sub-classes and not this class directly. Known sub-classes are:
- DailyRecurrence, MonthlyRecurrence, WeeklyRecurrence
-
- All required parameters must be populated in order to send to Azure.
+ Variables are only populated by the server, and will be ignored when sending a request.
- :ivar recurrence_type: Specifies when the recurrence should be applied. Required. Known values
- are: "Daily", "Weekly", and "Monthly".
- :vartype recurrence_type: str or ~azure.mgmt.alertsmanagement.models.RecurrenceType
- :ivar start_time: Start time for recurrence.
- :vartype start_time: str
- :ivar end_time: End time for recurrence.
- :vartype end_time: str
+ :ivar parent_alert_id: Unique Id (GUID) of the alert that this alert was correlated to.
+ :vartype parent_alert_id: str
+ :ivar correlation_date_time: The alert's correlation date time in ISO-8601 format.
+ :vartype correlation_date_time: ~datetime.datetime
+ :ivar alert_processing_rule: The alert processing rule that was used to correlate this alert.
+ This is an optional field, it will be presented only for a parent alert.
+ :vartype alert_processing_rule: str
"""
_validation = {
- "recurrence_type": {"required": True},
+ "parent_alert_id": {"readonly": True},
+ "correlation_date_time": {"readonly": True},
+ "alert_processing_rule": {"readonly": True},
}
_attribute_map = {
- "recurrence_type": {"key": "recurrenceType", "type": "str"},
- "start_time": {"key": "startTime", "type": "str"},
- "end_time": {"key": "endTime", "type": "str"},
+ "parent_alert_id": {"key": "parentAlertId", "type": "str"},
+ "correlation_date_time": {"key": "correlationDateTime", "type": "iso-8601"},
+ "alert_processing_rule": {"key": "alertProcessingRule", "type": "str"},
}
- _subtype_map = {
- "recurrence_type": {"Daily": "DailyRecurrence", "Monthly": "MonthlyRecurrence", "Weekly": "WeeklyRecurrence"}
- }
-
- def __init__(self, *, start_time: Optional[str] = None, end_time: Optional[str] = None, **kwargs):
- """
- :keyword start_time: Start time for recurrence.
- :paramtype start_time: str
- :keyword end_time: End time for recurrence.
- :paramtype end_time: str
- """
+ def __init__(self, **kwargs: Any) -> None:
+ """ """
super().__init__(**kwargs)
- self.recurrence_type: Optional[str] = None
- self.start_time = start_time
- self.end_time = end_time
-
-
-class DailyRecurrence(Recurrence):
- """Daily recurrence object.
-
- All required parameters must be populated in order to send to Azure.
-
- :ivar recurrence_type: Specifies when the recurrence should be applied. Required. Known values
- are: "Daily", "Weekly", and "Monthly".
- :vartype recurrence_type: str or ~azure.mgmt.alertsmanagement.models.RecurrenceType
- :ivar start_time: Start time for recurrence.
- :vartype start_time: str
- :ivar end_time: End time for recurrence.
- :vartype end_time: str
- """
-
- _validation = {
- "recurrence_type": {"required": True},
- }
-
- _attribute_map = {
- "recurrence_type": {"key": "recurrenceType", "type": "str"},
- "start_time": {"key": "startTime", "type": "str"},
- "end_time": {"key": "endTime", "type": "str"},
- }
-
- def __init__(self, *, start_time: Optional[str] = None, end_time: Optional[str] = None, **kwargs):
- """
- :keyword start_time: Start time for recurrence.
- :paramtype start_time: str
- :keyword end_time: End time for recurrence.
- :paramtype end_time: str
- """
- super().__init__(start_time=start_time, end_time=end_time, **kwargs)
- self.recurrence_type: str = "Daily"
+ self.parent_alert_id = None
+ self.correlation_date_time = None
+ self.alert_processing_rule = None
class ErrorAdditionalInfo(_serialization.Model):
@@ -917,14 +955,57 @@ class ErrorAdditionalInfo(_serialization.Model):
"info": {"key": "info", "type": "object"},
}
- def __init__(self, **kwargs):
+ def __init__(self, **kwargs: Any) -> None:
""" """
super().__init__(**kwargs)
self.type = None
self.info = None
-class ErrorDetail(_serialization.Model):
+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.alertsmanagement.models.ErrorDetail]
+ :ivar additional_info: The error additional info.
+ :vartype additional_info: list[~azure.mgmt.alertsmanagement.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 = None
+ self.message = None
+ self.target = None
+ self.details = None
+ self.additional_info = None
+
+
+class ErrorDetailAutoGenerated(_serialization.Model):
"""The error detail.
Variables are only populated by the server, and will be ignored when sending a request.
@@ -936,7 +1017,7 @@ class ErrorDetail(_serialization.Model):
:ivar target: The error target.
:vartype target: str
:ivar details: The error details.
- :vartype details: list[~azure.mgmt.alertsmanagement.models.ErrorDetail]
+ :vartype details: list[~azure.mgmt.alertsmanagement.models.ErrorDetailAutoGenerated]
:ivar additional_info: The error additional info.
:vartype additional_info: list[~azure.mgmt.alertsmanagement.models.ErrorAdditionalInfo]
"""
@@ -953,11 +1034,11 @@ class ErrorDetail(_serialization.Model):
"code": {"key": "code", "type": "str"},
"message": {"key": "message", "type": "str"},
"target": {"key": "target", "type": "str"},
- "details": {"key": "details", "type": "[ErrorDetail]"},
+ "details": {"key": "details", "type": "[ErrorDetailAutoGenerated]"},
"additional_info": {"key": "additionalInfo", "type": "[ErrorAdditionalInfo]"},
}
- def __init__(self, **kwargs):
+ def __init__(self, **kwargs: Any) -> None:
""" """
super().__init__(**kwargs)
self.code = None
@@ -968,60 +1049,62 @@ def __init__(self, **kwargs):
class ErrorResponse(_serialization.Model):
- """An error response from the service.
+ """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: Details of error response.
- :vartype error: ~azure.mgmt.alertsmanagement.models.ErrorResponseBody
+ :ivar error: The error object.
+ :vartype error: ~azure.mgmt.alertsmanagement.models.ErrorDetail
"""
_attribute_map = {
- "error": {"key": "error", "type": "ErrorResponseBody"},
+ "error": {"key": "error", "type": "ErrorDetail"},
}
- def __init__(self, *, error: Optional["_models.ErrorResponseBody"] = None, **kwargs):
+ def __init__(self, *, error: Optional["_models.ErrorDetail"] = None, **kwargs: Any) -> None:
"""
- :keyword error: Details of error response.
- :paramtype error: ~azure.mgmt.alertsmanagement.models.ErrorResponseBody
+ :keyword error: The error object.
+ :paramtype error: ~azure.mgmt.alertsmanagement.models.ErrorDetail
"""
super().__init__(**kwargs)
self.error = error
class ErrorResponseAutoGenerated(_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.).
+ """An error response from the service.
- :ivar error: The error object.
- :vartype error: ~azure.mgmt.alertsmanagement.models.ErrorDetail
+ :ivar error: Details of error response.
+ :vartype error: ~azure.mgmt.alertsmanagement.models.ErrorResponseBody
"""
_attribute_map = {
- "error": {"key": "error", "type": "ErrorDetail"},
+ "error": {"key": "error", "type": "ErrorResponseBody"},
}
- def __init__(self, *, error: Optional["_models.ErrorDetail"] = None, **kwargs):
+ def __init__(self, *, error: Optional["_models.ErrorResponseBody"] = None, **kwargs: Any) -> None:
"""
- :keyword error: The error object.
- :paramtype error: ~azure.mgmt.alertsmanagement.models.ErrorDetail
+ :keyword error: Details of error response.
+ :paramtype error: ~azure.mgmt.alertsmanagement.models.ErrorResponseBody
"""
super().__init__(**kwargs)
self.error = error
class ErrorResponseAutoGenerated2(_serialization.Model):
- """An error response from the service.
+ """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: Details of error response.
- :vartype error: ~azure.mgmt.alertsmanagement.models.ErrorResponseBodyAutoGenerated
+ :ivar error: The error object.
+ :vartype error: ~azure.mgmt.alertsmanagement.models.ErrorDetailAutoGenerated
"""
_attribute_map = {
- "error": {"key": "error", "type": "ErrorResponseBodyAutoGenerated"},
+ "error": {"key": "error", "type": "ErrorDetailAutoGenerated"},
}
- def __init__(self, *, error: Optional["_models.ErrorResponseBodyAutoGenerated"] = None, **kwargs):
+ def __init__(self, *, error: Optional["_models.ErrorDetailAutoGenerated"] = None, **kwargs: Any) -> None:
"""
- :keyword error: Details of error response.
- :paramtype error: ~azure.mgmt.alertsmanagement.models.ErrorResponseBodyAutoGenerated
+ :keyword error: The error object.
+ :paramtype error: ~azure.mgmt.alertsmanagement.models.ErrorDetailAutoGenerated
"""
super().__init__(**kwargs)
self.error = error
@@ -1031,17 +1114,17 @@ class ErrorResponseAutoGenerated3(_serialization.Model):
"""An error response from the service.
:ivar error: Details of error response.
- :vartype error: ~azure.mgmt.alertsmanagement.models.ErrorResponseBodyAutoGenerated2
+ :vartype error: ~azure.mgmt.alertsmanagement.models.ErrorResponseBodyAutoGenerated
"""
_attribute_map = {
- "error": {"key": "error", "type": "ErrorResponseBodyAutoGenerated2"},
+ "error": {"key": "error", "type": "ErrorResponseBodyAutoGenerated"},
}
- def __init__(self, *, error: Optional["_models.ErrorResponseBodyAutoGenerated2"] = None, **kwargs):
+ def __init__(self, *, error: Optional["_models.ErrorResponseBodyAutoGenerated"] = None, **kwargs: Any) -> None:
"""
:keyword error: Details of error response.
- :paramtype error: ~azure.mgmt.alertsmanagement.models.ErrorResponseBodyAutoGenerated2
+ :paramtype error: ~azure.mgmt.alertsmanagement.models.ErrorResponseBodyAutoGenerated
"""
super().__init__(**kwargs)
self.error = error
@@ -1074,8 +1157,8 @@ def __init__(
message: Optional[str] = None,
target: Optional[str] = None,
details: Optional[List["_models.ErrorResponseBody"]] = None,
- **kwargs
- ):
+ **kwargs: Any
+ ) -> None:
"""
:keyword code: Error code, intended to be consumed programmatically.
:paramtype code: str
@@ -1120,8 +1203,8 @@ def __init__(
message: Optional[str] = None,
target: Optional[str] = None,
details: Optional[List["_models.ErrorResponseBodyAutoGenerated"]] = None,
- **kwargs
- ):
+ **kwargs: Any
+ ) -> None:
"""
:keyword code: Error code, intended to be consumed programmatically.
:paramtype code: str
@@ -1139,53 +1222,7 @@ def __init__(
self.details = details
-class ErrorResponseBodyAutoGenerated2(_serialization.Model):
- """Details of error response.
-
- :ivar code: Error code, intended to be consumed programmatically.
- :vartype code: str
- :ivar message: Description of the error, intended for display in user interface.
- :vartype message: str
- :ivar target: Target of the particular error, for example name of the property.
- :vartype target: str
- :ivar details: A list of additional details about the error.
- :vartype details: list[~azure.mgmt.alertsmanagement.models.ErrorResponseBodyAutoGenerated2]
- """
-
- _attribute_map = {
- "code": {"key": "code", "type": "str"},
- "message": {"key": "message", "type": "str"},
- "target": {"key": "target", "type": "str"},
- "details": {"key": "details", "type": "[ErrorResponseBodyAutoGenerated2]"},
- }
-
- def __init__(
- self,
- *,
- code: Optional[str] = None,
- message: Optional[str] = None,
- target: Optional[str] = None,
- details: Optional[List["_models.ErrorResponseBodyAutoGenerated2"]] = None,
- **kwargs
- ):
- """
- :keyword code: Error code, intended to be consumed programmatically.
- :paramtype code: str
- :keyword message: Description of the error, intended for display in user interface.
- :paramtype message: str
- :keyword target: Target of the particular error, for example name of the property.
- :paramtype target: str
- :keyword details: A list of additional details about the error.
- :paramtype details: list[~azure.mgmt.alertsmanagement.models.ErrorResponseBodyAutoGenerated2]
- """
- super().__init__(**kwargs)
- self.code = code
- self.message = message
- self.target = target
- self.details = details
-
-
-class Essentials(_serialization.Model): # pylint: disable=too-many-instance-attributes
+class Essentials(_serialization.Model):
"""This object contains consistent fields across different monitor services.
Variables are only populated by the server, and will be ignored when sending a request.
@@ -1214,7 +1251,8 @@ class Essentials(_serialization.Model): # pylint: disable=too-many-instance-att
:ivar monitor_service: Monitor service on which the rule(monitor) is set. Known values are:
"Application Insights", "ActivityLog Administrative", "ActivityLog Security", "ActivityLog
Recommendation", "ActivityLog Policy", "ActivityLog Autoscale", "Log Analytics", "Nagios",
- "Platform", "SCOM", "ServiceHealth", "SmartDetector", "VM Insights", and "Zabbix".
+ "Platform", "SCOM", "ServiceHealth", "SmartDetector", "VM Insights", "Zabbix", and "Resource
+ Health".
:vartype monitor_service: str or ~azure.mgmt.alertsmanagement.models.MonitorService
:ivar alert_rule: Rule(monitor) which fired alert instance. Depending on the monitor service,
this would be ARM id or name of the rule.
@@ -1242,6 +1280,12 @@ class Essentials(_serialization.Model): # pylint: disable=too-many-instance-att
:vartype action_status: ~azure.mgmt.alertsmanagement.models.ActionStatus
:ivar description: Alert description.
:vartype description: str
+ :ivar has_enrichments: Will be presented with the value true only if there are enrichments.
+ :vartype has_enrichments: bool
+ :ivar is_stateful_alert: True if the alert is stateful, and false if it isn't.
+ :vartype is_stateful_alert: bool
+ :ivar correlation_details: Correlation details.
+ :vartype correlation_details: ~azure.mgmt.alertsmanagement.models.CorrelationDetails
"""
_validation = {
@@ -1258,6 +1302,8 @@ class Essentials(_serialization.Model): # pylint: disable=too-many-instance-att
"last_modified_date_time": {"readonly": True},
"monitor_condition_resolved_date_time": {"readonly": True},
"last_modified_user_name": {"readonly": True},
+ "has_enrichments": {"readonly": True},
+ "is_stateful_alert": {"readonly": True},
}
_attribute_map = {
@@ -1280,6 +1326,9 @@ class Essentials(_serialization.Model): # pylint: disable=too-many-instance-att
"last_modified_user_name": {"key": "lastModifiedUserName", "type": "str"},
"action_status": {"key": "actionStatus", "type": "ActionStatus"},
"description": {"key": "description", "type": "str"},
+ "has_enrichments": {"key": "hasEnrichments", "type": "bool"},
+ "is_stateful_alert": {"key": "isStatefulAlert", "type": "bool"},
+ "correlation_details": {"key": "correlationDetails", "type": "CorrelationDetails"},
}
def __init__(
@@ -1291,8 +1340,9 @@ def __init__(
target_resource_type: Optional[str] = None,
action_status: Optional["_models.ActionStatus"] = None,
description: Optional[str] = None,
- **kwargs
- ):
+ correlation_details: Optional["_models.CorrelationDetails"] = None,
+ **kwargs: Any
+ ) -> None:
"""
:keyword target_resource: Target ARM resource, on which alert got created.
:paramtype target_resource: str
@@ -1309,6 +1359,8 @@ def __init__(
:paramtype action_status: ~azure.mgmt.alertsmanagement.models.ActionStatus
:keyword description: Alert description.
:paramtype description: str
+ :keyword correlation_details: Correlation details.
+ :paramtype correlation_details: ~azure.mgmt.alertsmanagement.models.CorrelationDetails
"""
super().__init__(**kwargs)
self.severity = None
@@ -1330,6 +1382,9 @@ def __init__(
self.last_modified_user_name = None
self.action_status = action_status
self.description = description
+ self.has_enrichments = None
+ self.is_stateful_alert = None
+ self.correlation_details = correlation_details
class MonitorServiceDetails(_serialization.Model):
@@ -1346,7 +1401,7 @@ class MonitorServiceDetails(_serialization.Model):
"display_name": {"key": "displayName", "type": "str"},
}
- def __init__(self, *, name: Optional[str] = None, display_name: Optional[str] = None, **kwargs):
+ def __init__(self, *, name: Optional[str] = None, display_name: Optional[str] = None, **kwargs: Any) -> None:
"""
:keyword name: Monitor service name.
:paramtype name: str
@@ -1361,7 +1416,7 @@ def __init__(self, *, name: Optional[str] = None, display_name: Optional[str] =
class MonitorServiceList(AlertsMetaDataProperties):
"""Monitor service details.
- All required parameters must be populated in order to send to Azure.
+ All required parameters must be populated in order to send to server.
:ivar metadata_identifier: Identification of the information to be retrieved by API call.
Required. "MonitorServiceList"
@@ -1380,7 +1435,7 @@ class MonitorServiceList(AlertsMetaDataProperties):
"data": {"key": "data", "type": "[MonitorServiceDetails]"},
}
- def __init__(self, *, data: List["_models.MonitorServiceDetails"], **kwargs):
+ def __init__(self, *, data: List["_models.MonitorServiceDetails"], **kwargs: Any) -> None:
"""
:keyword data: Array of operations. Required.
:paramtype data: list[~azure.mgmt.alertsmanagement.models.MonitorServiceDetails]
@@ -1390,50 +1445,6 @@ def __init__(self, *, data: List["_models.MonitorServiceDetails"], **kwargs):
self.data = data
-class MonthlyRecurrence(Recurrence):
- """Monthly recurrence object.
-
- All required parameters must be populated in order to send to Azure.
-
- :ivar recurrence_type: Specifies when the recurrence should be applied. Required. Known values
- are: "Daily", "Weekly", and "Monthly".
- :vartype recurrence_type: str or ~azure.mgmt.alertsmanagement.models.RecurrenceType
- :ivar start_time: Start time for recurrence.
- :vartype start_time: str
- :ivar end_time: End time for recurrence.
- :vartype end_time: str
- :ivar days_of_month: Specifies the values for monthly recurrence pattern. Required.
- :vartype days_of_month: list[int]
- """
-
- _validation = {
- "recurrence_type": {"required": True},
- "days_of_month": {"required": True},
- }
-
- _attribute_map = {
- "recurrence_type": {"key": "recurrenceType", "type": "str"},
- "start_time": {"key": "startTime", "type": "str"},
- "end_time": {"key": "endTime", "type": "str"},
- "days_of_month": {"key": "daysOfMonth", "type": "[int]"},
- }
-
- def __init__(
- self, *, days_of_month: List[int], start_time: Optional[str] = None, end_time: Optional[str] = None, **kwargs
- ):
- """
- :keyword start_time: Start time for recurrence.
- :paramtype start_time: str
- :keyword end_time: End time for recurrence.
- :paramtype end_time: str
- :keyword days_of_month: Specifies the values for monthly recurrence pattern. Required.
- :paramtype days_of_month: list[int]
- """
- super().__init__(start_time=start_time, end_time=end_time, **kwargs)
- self.recurrence_type: str = "Monthly"
- self.days_of_month = days_of_month
-
-
class Operation(_serialization.Model):
"""Operation provided by provider.
@@ -1457,8 +1468,8 @@ def __init__(
name: Optional[str] = None,
display: Optional["_models.OperationDisplay"] = None,
origin: Optional[str] = None,
- **kwargs
- ):
+ **kwargs: Any
+ ) -> None:
"""
:keyword name: Name of the operation.
:paramtype name: str
@@ -1500,8 +1511,8 @@ def __init__(
resource: Optional[str] = None,
operation: Optional[str] = None,
description: Optional[str] = None,
- **kwargs
- ):
+ **kwargs: Any
+ ) -> None:
"""
:keyword provider: Provider name.
:paramtype provider: str
@@ -1522,7 +1533,7 @@ def __init__(
class OperationsList(_serialization.Model):
"""Lists the operations available in the AlertsManagement RP.
- All required parameters must be populated in order to send to Azure.
+ All required parameters must be populated in order to send to server.
:ivar next_link: URL to fetch the next set of alerts.
:vartype next_link: str
@@ -1539,7 +1550,7 @@ class OperationsList(_serialization.Model):
"value": {"key": "value", "type": "[Operation]"},
}
- def __init__(self, *, value: List["_models.Operation"], next_link: Optional[str] = None, **kwargs):
+ def __init__(self, *, value: List["_models.Operation"], next_link: Optional[str] = None, **kwargs: Any) -> None:
"""
:keyword next_link: URL to fetch the next set of alerts.
:paramtype next_link: str
@@ -1551,58 +1562,357 @@ def __init__(self, *, value: List["_models.Operation"], next_link: Optional[str]
self.value = value
-class PatchObject(_serialization.Model):
- """Data contract for patch.
+class PrometheusEnrichmentItem(AlertEnrichmentItem):
+ """Prometheus enrichment object.
- :ivar tags: Tags to be updated.
- :vartype tags: dict[str, str]
- :ivar enabled: Indicates if the given alert processing rule is enabled or disabled.
- :vartype enabled: bool
+ You probably want to use the sub-classes and not this class directly. Known sub-classes are:
+ PrometheusInstantQuery, PrometheusRangeQuery
+
+ All required parameters must be populated in order to send to server.
+
+ :ivar title: The enrichment title. Required.
+ :vartype title: str
+ :ivar description: The enrichment description. Required.
+ :vartype description: str
+ :ivar status: The status of the evaluation of the enrichment. Required. Known values are:
+ "Succeeded" and "Failed".
+ :vartype status: str or ~azure.mgmt.alertsmanagement.models.Status
+ :ivar error_message: The error message. Will be present only if the status is 'Failed'.
+ :vartype error_message: str
+ :ivar type: The enrichment type. Required. Known values are: "PrometheusInstantQuery" and
+ "PrometheusRangeQuery".
+ :vartype type: str or ~azure.mgmt.alertsmanagement.models.Type
+ :ivar link_to_api: Link to Prometheus query API (Url format). Required.
+ :vartype link_to_api: str
+ :ivar datasources: An array of the azure monitor workspace resource ids. Required.
+ :vartype datasources: list[str]
+ :ivar grafana_explore_path: Partial link to the Grafana explore API. Required.
+ :vartype grafana_explore_path: str
+ :ivar query: The Prometheus expression query. Required.
+ :vartype query: str
"""
+ _validation = {
+ "title": {"required": True},
+ "description": {"required": True},
+ "status": {"required": True},
+ "type": {"required": True},
+ "link_to_api": {"required": True},
+ "datasources": {"required": True},
+ "grafana_explore_path": {"required": True},
+ "query": {"required": True},
+ }
+
_attribute_map = {
- "tags": {"key": "tags", "type": "{str}"},
- "enabled": {"key": "properties.enabled", "type": "bool"},
+ "title": {"key": "title", "type": "str"},
+ "description": {"key": "description", "type": "str"},
+ "status": {"key": "status", "type": "str"},
+ "error_message": {"key": "errorMessage", "type": "str"},
+ "type": {"key": "type", "type": "str"},
+ "link_to_api": {"key": "linkToApi", "type": "str"},
+ "datasources": {"key": "datasources", "type": "[str]"},
+ "grafana_explore_path": {"key": "grafanaExplorePath", "type": "str"},
+ "query": {"key": "query", "type": "str"},
}
- def __init__(self, *, tags: Optional[Dict[str, str]] = None, enabled: Optional[bool] = None, **kwargs):
- """
- :keyword tags: Tags to be updated.
- :paramtype tags: dict[str, str]
- :keyword enabled: Indicates if the given alert processing rule is enabled or disabled.
- :paramtype enabled: bool
- """
- super().__init__(**kwargs)
- self.tags = tags
- self.enabled = enabled
+ _subtype_map = {
+ "type": {"PrometheusInstantQuery": "PrometheusInstantQuery", "PrometheusRangeQuery": "PrometheusRangeQuery"}
+ }
+
+ def __init__(
+ self,
+ *,
+ title: str,
+ description: str,
+ status: Union[str, "_models.Status"],
+ link_to_api: str,
+ datasources: List[str],
+ grafana_explore_path: str,
+ query: str,
+ error_message: Optional[str] = None,
+ **kwargs: Any
+ ) -> None:
+ """
+ :keyword title: The enrichment title. Required.
+ :paramtype title: str
+ :keyword description: The enrichment description. Required.
+ :paramtype description: str
+ :keyword status: The status of the evaluation of the enrichment. Required. Known values are:
+ "Succeeded" and "Failed".
+ :paramtype status: str or ~azure.mgmt.alertsmanagement.models.Status
+ :keyword error_message: The error message. Will be present only if the status is 'Failed'.
+ :paramtype error_message: str
+ :keyword link_to_api: Link to Prometheus query API (Url format). Required.
+ :paramtype link_to_api: str
+ :keyword datasources: An array of the azure monitor workspace resource ids. Required.
+ :paramtype datasources: list[str]
+ :keyword grafana_explore_path: Partial link to the Grafana explore API. Required.
+ :paramtype grafana_explore_path: str
+ :keyword query: The Prometheus expression query. Required.
+ :paramtype query: str
+ """
+ super().__init__(title=title, description=description, status=status, error_message=error_message, **kwargs)
+ self.type: str = "PrometheusEnrichmentItem"
+ self.link_to_api = link_to_api
+ self.datasources = datasources
+ self.grafana_explore_path = grafana_explore_path
+ self.query = query
+
+
+class PrometheusInstantQuery(PrometheusEnrichmentItem):
+ """Prometheus instant query enrichment object.
+
+ All required parameters must be populated in order to send to server.
+
+ :ivar title: The enrichment title. Required.
+ :vartype title: str
+ :ivar description: The enrichment description. Required.
+ :vartype description: str
+ :ivar status: The status of the evaluation of the enrichment. Required. Known values are:
+ "Succeeded" and "Failed".
+ :vartype status: str or ~azure.mgmt.alertsmanagement.models.Status
+ :ivar error_message: The error message. Will be present only if the status is 'Failed'.
+ :vartype error_message: str
+ :ivar type: The enrichment type. Required. Known values are: "PrometheusInstantQuery" and
+ "PrometheusRangeQuery".
+ :vartype type: str or ~azure.mgmt.alertsmanagement.models.Type
+ :ivar link_to_api: Link to Prometheus query API (Url format). Required.
+ :vartype link_to_api: str
+ :ivar datasources: An array of the azure monitor workspace resource ids. Required.
+ :vartype datasources: list[str]
+ :ivar grafana_explore_path: Partial link to the Grafana explore API. Required.
+ :vartype grafana_explore_path: str
+ :ivar query: The Prometheus expression query. Required.
+ :vartype query: str
+ :ivar time: The date and the time of the evaluation. Required.
+ :vartype time: str
+ """
+
+ _validation = {
+ "title": {"required": True},
+ "description": {"required": True},
+ "status": {"required": True},
+ "type": {"required": True},
+ "link_to_api": {"required": True},
+ "datasources": {"required": True},
+ "grafana_explore_path": {"required": True},
+ "query": {"required": True},
+ "time": {"required": True},
+ }
+
+ _attribute_map = {
+ "title": {"key": "title", "type": "str"},
+ "description": {"key": "description", "type": "str"},
+ "status": {"key": "status", "type": "str"},
+ "error_message": {"key": "errorMessage", "type": "str"},
+ "type": {"key": "type", "type": "str"},
+ "link_to_api": {"key": "linkToApi", "type": "str"},
+ "datasources": {"key": "datasources", "type": "[str]"},
+ "grafana_explore_path": {"key": "grafanaExplorePath", "type": "str"},
+ "query": {"key": "query", "type": "str"},
+ "time": {"key": "time", "type": "str"},
+ }
+
+ def __init__(
+ self,
+ *,
+ title: str,
+ description: str,
+ status: Union[str, "_models.Status"],
+ link_to_api: str,
+ datasources: List[str],
+ grafana_explore_path: str,
+ query: str,
+ time: str,
+ error_message: Optional[str] = None,
+ **kwargs: Any
+ ) -> None:
+ """
+ :keyword title: The enrichment title. Required.
+ :paramtype title: str
+ :keyword description: The enrichment description. Required.
+ :paramtype description: str
+ :keyword status: The status of the evaluation of the enrichment. Required. Known values are:
+ "Succeeded" and "Failed".
+ :paramtype status: str or ~azure.mgmt.alertsmanagement.models.Status
+ :keyword error_message: The error message. Will be present only if the status is 'Failed'.
+ :paramtype error_message: str
+ :keyword link_to_api: Link to Prometheus query API (Url format). Required.
+ :paramtype link_to_api: str
+ :keyword datasources: An array of the azure monitor workspace resource ids. Required.
+ :paramtype datasources: list[str]
+ :keyword grafana_explore_path: Partial link to the Grafana explore API. Required.
+ :paramtype grafana_explore_path: str
+ :keyword query: The Prometheus expression query. Required.
+ :paramtype query: str
+ :keyword time: The date and the time of the evaluation. Required.
+ :paramtype time: str
+ """
+ super().__init__(
+ title=title,
+ description=description,
+ status=status,
+ error_message=error_message,
+ link_to_api=link_to_api,
+ datasources=datasources,
+ grafana_explore_path=grafana_explore_path,
+ query=query,
+ **kwargs
+ )
+ self.type: str = "PrometheusInstantQuery"
+ self.time = time
+
+
+class PrometheusRangeQuery(PrometheusEnrichmentItem):
+ """Prometheus instant query enrichment object.
+
+ All required parameters must be populated in order to send to server.
+
+ :ivar title: The enrichment title. Required.
+ :vartype title: str
+ :ivar description: The enrichment description. Required.
+ :vartype description: str
+ :ivar status: The status of the evaluation of the enrichment. Required. Known values are:
+ "Succeeded" and "Failed".
+ :vartype status: str or ~azure.mgmt.alertsmanagement.models.Status
+ :ivar error_message: The error message. Will be present only if the status is 'Failed'.
+ :vartype error_message: str
+ :ivar type: The enrichment type. Required. Known values are: "PrometheusInstantQuery" and
+ "PrometheusRangeQuery".
+ :vartype type: str or ~azure.mgmt.alertsmanagement.models.Type
+ :ivar link_to_api: Link to Prometheus query API (Url format). Required.
+ :vartype link_to_api: str
+ :ivar datasources: An array of the azure monitor workspace resource ids. Required.
+ :vartype datasources: list[str]
+ :ivar grafana_explore_path: Partial link to the Grafana explore API. Required.
+ :vartype grafana_explore_path: str
+ :ivar query: The Prometheus expression query. Required.
+ :vartype query: str
+ :ivar start: The start evaluation date and time in ISO8601 format. Required.
+ :vartype start: ~datetime.datetime
+ :ivar end: The end evaluation date and time in ISO8601 format. Required.
+ :vartype end: ~datetime.datetime
+ :ivar step: Query resolution step width in ISO8601 format. Required.
+ :vartype step: str
+ """
+
+ _validation = {
+ "title": {"required": True},
+ "description": {"required": True},
+ "status": {"required": True},
+ "type": {"required": True},
+ "link_to_api": {"required": True},
+ "datasources": {"required": True},
+ "grafana_explore_path": {"required": True},
+ "query": {"required": True},
+ "start": {"required": True},
+ "end": {"required": True},
+ "step": {"required": True},
+ }
+
+ _attribute_map = {
+ "title": {"key": "title", "type": "str"},
+ "description": {"key": "description", "type": "str"},
+ "status": {"key": "status", "type": "str"},
+ "error_message": {"key": "errorMessage", "type": "str"},
+ "type": {"key": "type", "type": "str"},
+ "link_to_api": {"key": "linkToApi", "type": "str"},
+ "datasources": {"key": "datasources", "type": "[str]"},
+ "grafana_explore_path": {"key": "grafanaExplorePath", "type": "str"},
+ "query": {"key": "query", "type": "str"},
+ "start": {"key": "start", "type": "iso-8601"},
+ "end": {"key": "end", "type": "iso-8601"},
+ "step": {"key": "step", "type": "str"},
+ }
+
+ def __init__(
+ self,
+ *,
+ title: str,
+ description: str,
+ status: Union[str, "_models.Status"],
+ link_to_api: str,
+ datasources: List[str],
+ grafana_explore_path: str,
+ query: str,
+ start: datetime.datetime,
+ end: datetime.datetime,
+ step: str,
+ error_message: Optional[str] = None,
+ **kwargs: Any
+ ) -> None:
+ """
+ :keyword title: The enrichment title. Required.
+ :paramtype title: str
+ :keyword description: The enrichment description. Required.
+ :paramtype description: str
+ :keyword status: The status of the evaluation of the enrichment. Required. Known values are:
+ "Succeeded" and "Failed".
+ :paramtype status: str or ~azure.mgmt.alertsmanagement.models.Status
+ :keyword error_message: The error message. Will be present only if the status is 'Failed'.
+ :paramtype error_message: str
+ :keyword link_to_api: Link to Prometheus query API (Url format). Required.
+ :paramtype link_to_api: str
+ :keyword datasources: An array of the azure monitor workspace resource ids. Required.
+ :paramtype datasources: list[str]
+ :keyword grafana_explore_path: Partial link to the Grafana explore API. Required.
+ :paramtype grafana_explore_path: str
+ :keyword query: The Prometheus expression query. Required.
+ :paramtype query: str
+ :keyword start: The start evaluation date and time in ISO8601 format. Required.
+ :paramtype start: ~datetime.datetime
+ :keyword end: The end evaluation date and time in ISO8601 format. Required.
+ :paramtype end: ~datetime.datetime
+ :keyword step: Query resolution step width in ISO8601 format. Required.
+ :paramtype step: str
+ """
+ super().__init__(
+ title=title,
+ description=description,
+ status=status,
+ error_message=error_message,
+ link_to_api=link_to_api,
+ datasources=datasources,
+ grafana_explore_path=grafana_explore_path,
+ query=query,
+ **kwargs
+ )
+ self.type: str = "PrometheusRangeQuery"
+ self.start = start
+ self.end = end
+ self.step = step
class PrometheusRule(_serialization.Model):
- """PrometheusRule.
+ """An Azure Prometheus alerting or recording rule.
- All required parameters must be populated in order to send to Azure.
+ All required parameters must be populated in order to send to server.
- :ivar record: the name of the recording rule.
+ :ivar record: Recorded metrics name.
:vartype record: str
- :ivar alert: the name of the alert rule.
+ :ivar alert: Alert rule name.
:vartype alert: str
- :ivar enabled: the flag that indicates whether the Prometheus rule is enabled.
+ :ivar enabled: Enable/disable rule.
:vartype enabled: bool
- :ivar expression: the expression to run for the rule. Required.
+ :ivar expression: The PromQL expression to evaluate.
+ https://prometheus.io/docs/prometheus/latest/querying/basics/. Evaluated periodically as given
+ by 'interval', and the result recorded as a new set of time series with the metric name as
+ given by 'record'. Required.
:vartype expression: str
- :ivar severity: the severity of the alerts fired by the rule. Only relevant for alerts.
- :vartype severity: int
- :ivar for_property: the amount of time alert must be active before firing. Only relevant for
- alerts.
- :vartype for_property: str
- :ivar labels: labels for rule group. Only relevant for alerts.
+ :ivar labels: Labels to add or overwrite before storing the result.
:vartype labels: dict[str, str]
- :ivar annotations: annotations for rule group. Only relevant for alerts.
+ :ivar severity: The severity of the alerts fired by the rule. Must be between 0 and 4.
+ :vartype severity: int
+ :ivar for_property: The amount of time alert must be active before firing.
+ :vartype for_property: ~datetime.timedelta
+ :ivar annotations: The annotations clause specifies a set of informational labels that can be
+ used to store longer additional information such as alert descriptions or runbook links. The
+ annotation values can be templated.
:vartype annotations: dict[str, str]
- :ivar actions: The array of actions that are performed when the alert rule becomes active, and
- when an alert condition is resolved. Only relevant for alerts.
+ :ivar actions: Actions that are performed when the alert rule becomes active, and when an alert
+ condition is resolved.
:vartype actions: list[~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupAction]
- :ivar resolve_configuration: defines the configuration for resolving fired alerts. Only
+ :ivar resolve_configuration: Defines the configuration for resolving fired alerts. Only
relevant for alerts.
:vartype resolve_configuration:
~azure.mgmt.alertsmanagement.models.PrometheusRuleResolveConfiguration
@@ -1617,9 +1927,9 @@ class PrometheusRule(_serialization.Model):
"alert": {"key": "alert", "type": "str"},
"enabled": {"key": "enabled", "type": "bool"},
"expression": {"key": "expression", "type": "str"},
- "severity": {"key": "severity", "type": "int"},
- "for_property": {"key": "for", "type": "str"},
"labels": {"key": "labels", "type": "{str}"},
+ "severity": {"key": "severity", "type": "int"},
+ "for_property": {"key": "for", "type": "duration"},
"annotations": {"key": "annotations", "type": "{str}"},
"actions": {"key": "actions", "type": "[PrometheusRuleGroupAction]"},
"resolve_configuration": {"key": "resolveConfiguration", "type": "PrometheusRuleResolveConfiguration"},
@@ -1632,36 +1942,40 @@ def __init__(
record: Optional[str] = None,
alert: Optional[str] = None,
enabled: Optional[bool] = None,
- severity: Optional[int] = None,
- for_property: Optional[str] = None,
labels: Optional[Dict[str, str]] = None,
+ severity: Optional[int] = None,
+ for_property: Optional[datetime.timedelta] = None,
annotations: Optional[Dict[str, str]] = None,
actions: Optional[List["_models.PrometheusRuleGroupAction"]] = None,
resolve_configuration: Optional["_models.PrometheusRuleResolveConfiguration"] = None,
- **kwargs
- ):
+ **kwargs: Any
+ ) -> None:
"""
- :keyword record: the name of the recording rule.
+ :keyword record: Recorded metrics name.
:paramtype record: str
- :keyword alert: the name of the alert rule.
+ :keyword alert: Alert rule name.
:paramtype alert: str
- :keyword enabled: the flag that indicates whether the Prometheus rule is enabled.
+ :keyword enabled: Enable/disable rule.
:paramtype enabled: bool
- :keyword expression: the expression to run for the rule. Required.
+ :keyword expression: The PromQL expression to evaluate.
+ https://prometheus.io/docs/prometheus/latest/querying/basics/. Evaluated periodically as given
+ by 'interval', and the result recorded as a new set of time series with the metric name as
+ given by 'record'. Required.
:paramtype expression: str
- :keyword severity: the severity of the alerts fired by the rule. Only relevant for alerts.
- :paramtype severity: int
- :keyword for_property: the amount of time alert must be active before firing. Only relevant for
- alerts.
- :paramtype for_property: str
- :keyword labels: labels for rule group. Only relevant for alerts.
+ :keyword labels: Labels to add or overwrite before storing the result.
:paramtype labels: dict[str, str]
- :keyword annotations: annotations for rule group. Only relevant for alerts.
+ :keyword severity: The severity of the alerts fired by the rule. Must be between 0 and 4.
+ :paramtype severity: int
+ :keyword for_property: The amount of time alert must be active before firing.
+ :paramtype for_property: ~datetime.timedelta
+ :keyword annotations: The annotations clause specifies a set of informational labels that can
+ be used to store longer additional information such as alert descriptions or runbook links. The
+ annotation values can be templated.
:paramtype annotations: dict[str, str]
- :keyword actions: The array of actions that are performed when the alert rule becomes active,
- and when an alert condition is resolved. Only relevant for alerts.
+ :keyword actions: Actions that are performed when the alert rule becomes active, and when an
+ alert condition is resolved.
:paramtype actions: list[~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupAction]
- :keyword resolve_configuration: defines the configuration for resolving fired alerts. Only
+ :keyword resolve_configuration: Defines the configuration for resolving fired alerts. Only
relevant for alerts.
:paramtype resolve_configuration:
~azure.mgmt.alertsmanagement.models.PrometheusRuleResolveConfiguration
@@ -1671,9 +1985,9 @@ def __init__(
self.alert = alert
self.enabled = enabled
self.expression = expression
+ self.labels = labels
self.severity = severity
self.for_property = for_property
- self.labels = labels
self.annotations = annotations
self.actions = actions
self.resolve_configuration = resolve_configuration
@@ -1694,8 +2008,12 @@ class PrometheusRuleGroupAction(_serialization.Model):
}
def __init__(
- self, *, action_group_id: Optional[str] = None, action_properties: Optional[Dict[str, str]] = None, **kwargs
- ):
+ self,
+ *,
+ action_group_id: Optional[str] = None,
+ action_properties: Optional[Dict[str, str]] = None,
+ **kwargs: Any
+ ) -> None:
"""
:keyword action_group_id: The resource id of the action group to use.
:paramtype action_group_id: str
@@ -1707,56 +2025,16 @@ def __init__(
self.action_properties = action_properties
-class ResourceAutoGenerated(_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. Ex -
- /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.alertsmanagement.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):
- """ """
- super().__init__(**kwargs)
- self.id = None
- self.name = None
- self.type = None
- self.system_data = None
-
-
-class TrackedResource(ResourceAutoGenerated):
- """The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location'.
+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 Azure.
+ All required parameters must be populated in order to send to server.
:ivar id: Fully qualified resource ID for the resource. Ex -
- /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
+ /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
@@ -1789,7 +2067,7 @@ class TrackedResource(ResourceAutoGenerated):
"location": {"key": "location", "type": "str"},
}
- def __init__(self, *, location: str, tags: Optional[Dict[str, str]] = None, **kwargs):
+ def __init__(self, *, location: str, tags: Optional[Dict[str, str]] = None, **kwargs: Any) -> None:
"""
:keyword tags: Resource tags.
:paramtype tags: dict[str, str]
@@ -1801,15 +2079,15 @@ def __init__(self, *, location: str, tags: Optional[Dict[str, str]] = None, **kw
self.location = location
-class PrometheusRuleGroupResource(TrackedResource): # pylint: disable=too-many-instance-attributes
+class PrometheusRuleGroupResource(TrackedResource):
"""The Prometheus rule group 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 Azure.
+ All required parameters must be populated in order to send to server.
:ivar id: Fully qualified resource ID for the resource. Ex -
- /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
+ /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
@@ -1823,19 +2101,19 @@ class PrometheusRuleGroupResource(TrackedResource): # pylint: disable=too-many-
:vartype tags: dict[str, str]
:ivar location: The geo-location where the resource lives. Required.
:vartype location: str
- :ivar description: the description of the Prometheus rule group that will be included in the
- alert email.
+ :ivar description: Rule group description.
:vartype description: str
- :ivar enabled: the flag that indicates whether the Prometheus rule group is enabled.
+ :ivar enabled: Enable/disable rule group.
:vartype enabled: bool
- :ivar cluster_name: the cluster name of the rule group evaluation.
+ :ivar cluster_name: Apply rule to data from a specific cluster.
:vartype cluster_name: str
- :ivar scopes: the list of resource id's that this rule group is scoped to. Required.
+ :ivar scopes: Target Azure Monitor workspaces resource ids. This api-version is currently
+ limited to creating with one scope. This may change in future. Required.
:vartype scopes: list[str]
- :ivar interval: the interval in which to run the Prometheus rule group represented in ISO 8601
+ :ivar interval: The interval in which to run the Prometheus rule group represented in ISO 8601
duration format. Should be between 1 and 15 minutes.
- :vartype interval: str
- :ivar rules: defines the rules in the Prometheus rule group. Required.
+ :vartype interval: ~datetime.timedelta
+ :ivar rules: Defines the rules in the Prometheus rule group. Required.
:vartype rules: list[~azure.mgmt.alertsmanagement.models.PrometheusRule]
"""
@@ -1860,7 +2138,7 @@ class PrometheusRuleGroupResource(TrackedResource): # pylint: disable=too-many-
"enabled": {"key": "properties.enabled", "type": "bool"},
"cluster_name": {"key": "properties.clusterName", "type": "str"},
"scopes": {"key": "properties.scopes", "type": "[str]"},
- "interval": {"key": "properties.interval", "type": "str"},
+ "interval": {"key": "properties.interval", "type": "duration"},
"rules": {"key": "properties.rules", "type": "[PrometheusRule]"},
}
@@ -1874,27 +2152,27 @@ def __init__(
description: Optional[str] = None,
enabled: Optional[bool] = None,
cluster_name: Optional[str] = None,
- interval: Optional[str] = None,
- **kwargs
- ):
+ interval: Optional[datetime.timedelta] = 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 description: the description of the Prometheus rule group that will be included in the
- alert email.
+ :keyword description: Rule group description.
:paramtype description: str
- :keyword enabled: the flag that indicates whether the Prometheus rule group is enabled.
+ :keyword enabled: Enable/disable rule group.
:paramtype enabled: bool
- :keyword cluster_name: the cluster name of the rule group evaluation.
+ :keyword cluster_name: Apply rule to data from a specific cluster.
:paramtype cluster_name: str
- :keyword scopes: the list of resource id's that this rule group is scoped to. Required.
+ :keyword scopes: Target Azure Monitor workspaces resource ids. This api-version is currently
+ limited to creating with one scope. This may change in future. Required.
:paramtype scopes: list[str]
- :keyword interval: the interval in which to run the Prometheus rule group represented in ISO
+ :keyword interval: The interval in which to run the Prometheus rule group represented in ISO
8601 duration format. Should be between 1 and 15 minutes.
- :paramtype interval: str
- :keyword rules: defines the rules in the Prometheus rule group. Required.
+ :paramtype interval: ~datetime.timedelta
+ :keyword rules: Defines the rules in the Prometheus rule group. Required.
:paramtype rules: list[~azure.mgmt.alertsmanagement.models.PrometheusRule]
"""
super().__init__(tags=tags, location=location, **kwargs)
@@ -1917,7 +2195,7 @@ class PrometheusRuleGroupResourceCollection(_serialization.Model):
"value": {"key": "value", "type": "[PrometheusRuleGroupResource]"},
}
- def __init__(self, *, value: Optional[List["_models.PrometheusRuleGroupResource"]] = None, **kwargs):
+ def __init__(self, *, value: Optional[List["_models.PrometheusRuleGroupResource"]] = None, **kwargs: Any) -> None:
"""
:keyword value: the values for the alert rule resources.
:paramtype value: list[~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource]
@@ -1926,170 +2204,130 @@ def __init__(self, *, value: Optional[List["_models.PrometheusRuleGroupResource"
self.value = value
-class PrometheusRuleGroupResourcePatch(_serialization.Model):
+class PrometheusRuleGroupResourcePatchParameters(_serialization.Model): # pylint: disable=name-too-long
"""The Prometheus rule group resource for patch operations.
:ivar tags: Resource tags.
:vartype tags: dict[str, str]
- :ivar properties:
- :vartype properties:
- ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResourcePatchProperties
+ :ivar enabled: the flag that indicates whether the Prometheus rule group is enabled.
+ :vartype enabled: bool
"""
_attribute_map = {
"tags": {"key": "tags", "type": "{str}"},
- "properties": {"key": "properties", "type": "PrometheusRuleGroupResourcePatchProperties"},
+ "enabled": {"key": "properties.enabled", "type": "bool"},
}
- def __init__(
- self,
- *,
- tags: Optional[Dict[str, str]] = None,
- properties: Optional["_models.PrometheusRuleGroupResourcePatchProperties"] = None,
- **kwargs
- ):
+ def __init__(self, *, tags: Optional[Dict[str, str]] = None, enabled: Optional[bool] = None, **kwargs: Any) -> None:
"""
:keyword tags: Resource tags.
:paramtype tags: dict[str, str]
- :keyword properties:
- :paramtype properties:
- ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResourcePatchProperties
- """
- super().__init__(**kwargs)
- self.tags = tags
- self.properties = properties
-
-
-class PrometheusRuleGroupResourcePatchProperties(_serialization.Model):
- """PrometheusRuleGroupResourcePatchProperties.
-
- :ivar enabled: the flag that indicates whether the Prometheus rule group is enabled.
- :vartype enabled: bool
- """
-
- _attribute_map = {
- "enabled": {"key": "enabled", "type": "bool"},
- }
-
- def __init__(self, *, enabled: Optional[bool] = None, **kwargs):
- """
:keyword enabled: the flag that indicates whether the Prometheus rule group is enabled.
:paramtype enabled: bool
"""
super().__init__(**kwargs)
+ self.tags = tags
self.enabled = enabled
class PrometheusRuleResolveConfiguration(_serialization.Model):
"""Specifies the Prometheus alert rule configuration.
- :ivar auto_resolved: the flag that indicates whether or not to auto resolve a fired alert.
+ :ivar auto_resolved: Enable alert auto-resolution.
:vartype auto_resolved: bool
- :ivar time_to_resolve: the duration a rule must evaluate as healthy before the fired alert is
- automatically resolved represented in ISO 8601 duration format. Should be between 1 and 15
- minutes.
- :vartype time_to_resolve: str
+ :ivar time_to_resolve: Alert auto-resolution timeout.
+ :vartype time_to_resolve: ~datetime.timedelta
"""
_attribute_map = {
"auto_resolved": {"key": "autoResolved", "type": "bool"},
- "time_to_resolve": {"key": "timeToResolve", "type": "str"},
+ "time_to_resolve": {"key": "timeToResolve", "type": "duration"},
}
- def __init__(self, *, auto_resolved: Optional[bool] = None, time_to_resolve: Optional[str] = None, **kwargs):
+ def __init__(
+ self,
+ *,
+ auto_resolved: Optional[bool] = None,
+ time_to_resolve: Optional[datetime.timedelta] = None,
+ **kwargs: Any
+ ) -> None:
"""
- :keyword auto_resolved: the flag that indicates whether or not to auto resolve a fired alert.
+ :keyword auto_resolved: Enable alert auto-resolution.
:paramtype auto_resolved: bool
- :keyword time_to_resolve: the duration a rule must evaluate as healthy before the fired alert
- is automatically resolved represented in ISO 8601 duration format. Should be between 1 and 15
- minutes.
- :paramtype time_to_resolve: str
+ :keyword time_to_resolve: Alert auto-resolution timeout.
+ :paramtype time_to_resolve: ~datetime.timedelta
"""
super().__init__(**kwargs)
self.auto_resolved = auto_resolved
self.time_to_resolve = time_to_resolve
-class RemoveAllActionGroups(Action):
- """Indicates if all action groups should be removed.
-
- All required parameters must be populated in order to send to Azure.
-
- :ivar action_type: Action that should be applied. Required. Known values are: "AddActionGroups"
- and "RemoveAllActionGroups".
- :vartype action_type: str or ~azure.mgmt.alertsmanagement.models.ActionType
- """
-
- _validation = {
- "action_type": {"required": True},
- }
+class RuleArmTemplate(_serialization.Model):
+ """A complete ARM template to deploy the alert rules.
- _attribute_map = {
- "action_type": {"key": "actionType", "type": "str"},
- }
+ All required parameters must be populated in order to send to server.
- def __init__(self, **kwargs):
- """ """
- super().__init__(**kwargs)
- self.action_type: str = "RemoveAllActionGroups"
-
-
-class Schedule(_serialization.Model):
- """Scheduling configuration for a given alert processing rule.
-
- :ivar effective_from: Scheduling effective from time. Date-Time in ISO-8601 format without
- timezone suffix.
- :vartype effective_from: str
- :ivar effective_until: Scheduling effective until time. Date-Time in ISO-8601 format without
- timezone suffix.
- :vartype effective_until: str
- :ivar time_zone: Scheduling time zone.
- :vartype time_zone: str
- :ivar recurrences: List of recurrences.
- :vartype recurrences: list[~azure.mgmt.alertsmanagement.models.Recurrence]
+ :ivar schema: JSON schema reference. Required.
+ :vartype schema: str
+ :ivar content_version: A 4 number format for the version number of this template file. For
+ example, 1.0.0.0. Required.
+ :vartype content_version: str
+ :ivar variables: Variable definitions. Required.
+ :vartype variables: JSON
+ :ivar parameters: Input parameter definitions. Required.
+ :vartype parameters: JSON
+ :ivar resources: Alert rule resource definitions. Required.
+ :vartype resources: list[JSON]
"""
_validation = {
- "effective_from": {"pattern": r"^(?:(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?))$"},
- "effective_until": {"pattern": r"^(?:(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?))$"},
+ "schema": {"required": True},
+ "content_version": {"required": True, "pattern": r"(^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$)"},
+ "variables": {"required": True},
+ "parameters": {"required": True},
+ "resources": {"required": True},
}
_attribute_map = {
- "effective_from": {"key": "effectiveFrom", "type": "str"},
- "effective_until": {"key": "effectiveUntil", "type": "str"},
- "time_zone": {"key": "timeZone", "type": "str"},
- "recurrences": {"key": "recurrences", "type": "[Recurrence]"},
+ "schema": {"key": "$schema", "type": "str"},
+ "content_version": {"key": "contentVersion", "type": "str"},
+ "variables": {"key": "variables", "type": "object"},
+ "parameters": {"key": "parameters", "type": "object"},
+ "resources": {"key": "resources", "type": "[object]"},
}
def __init__(
self,
*,
- effective_from: Optional[str] = None,
- effective_until: Optional[str] = None,
- time_zone: Optional[str] = None,
- recurrences: Optional[List["_models.Recurrence"]] = None,
- **kwargs
- ):
- """
- :keyword effective_from: Scheduling effective from time. Date-Time in ISO-8601 format without
- timezone suffix.
- :paramtype effective_from: str
- :keyword effective_until: Scheduling effective until time. Date-Time in ISO-8601 format without
- timezone suffix.
- :paramtype effective_until: str
- :keyword time_zone: Scheduling time zone.
- :paramtype time_zone: str
- :keyword recurrences: List of recurrences.
- :paramtype recurrences: list[~azure.mgmt.alertsmanagement.models.Recurrence]
+ schema: str,
+ content_version: str,
+ variables: JSON,
+ parameters: JSON,
+ resources: List[JSON],
+ **kwargs: Any
+ ) -> None:
+ """
+ :keyword schema: JSON schema reference. Required.
+ :paramtype schema: str
+ :keyword content_version: A 4 number format for the version number of this template file. For
+ example, 1.0.0.0. Required.
+ :paramtype content_version: str
+ :keyword variables: Variable definitions. Required.
+ :paramtype variables: JSON
+ :keyword parameters: Input parameter definitions. Required.
+ :paramtype parameters: JSON
+ :keyword resources: Alert rule resource definitions. Required.
+ :paramtype resources: list[JSON]
"""
super().__init__(**kwargs)
- self.effective_from = effective_from
- self.effective_until = effective_until
- self.time_zone = time_zone
- self.recurrences = recurrences
+ self.schema = schema
+ self.content_version = content_version
+ self.variables = variables
+ self.parameters = parameters
+ self.resources = resources
-class SmartGroup(Resource): # pylint: disable=too-many-instance-attributes
+class SmartGroup(ResourceAutoGenerated):
"""Set of related alerts grouped together smartly by AMS.
Variables are only populated by the server, and will be ignored when sending a request.
@@ -2180,8 +2418,8 @@ def __init__(
alert_states: Optional[List["_models.SmartGroupAggregatedProperty"]] = None,
alert_severities: Optional[List["_models.SmartGroupAggregatedProperty"]] = None,
next_link: Optional[str] = None,
- **kwargs
- ):
+ **kwargs: Any
+ ) -> None:
"""
:keyword alerts_count: Total number of alerts in smart group.
:paramtype alerts_count: int
@@ -2239,7 +2477,7 @@ class SmartGroupAggregatedProperty(_serialization.Model):
"count": {"key": "count", "type": "int"},
}
- def __init__(self, *, name: Optional[str] = None, count: Optional[int] = None, **kwargs):
+ def __init__(self, *, name: Optional[str] = None, count: Optional[int] = None, **kwargs: Any) -> None:
"""
:keyword name: Name of the type.
:paramtype name: str
@@ -2251,7 +2489,7 @@ def __init__(self, *, name: Optional[str] = None, count: Optional[int] = None, *
self.count = count
-class SmartGroupModification(Resource):
+class SmartGroupModification(ResourceAutoGenerated):
"""Alert Modification details.
Variables are only populated by the server, and will be ignored when sending a request.
@@ -2279,7 +2517,9 @@ class SmartGroupModification(Resource):
"properties": {"key": "properties", "type": "SmartGroupModificationProperties"},
}
- def __init__(self, *, properties: Optional["_models.SmartGroupModificationProperties"] = None, **kwargs):
+ def __init__(
+ self, *, properties: Optional["_models.SmartGroupModificationProperties"] = None, **kwargs: Any
+ ) -> None:
"""
:keyword properties: Properties of the smartGroup modification item.
:paramtype properties: ~azure.mgmt.alertsmanagement.models.SmartGroupModificationProperties
@@ -2329,8 +2569,8 @@ def __init__(
modified_by: Optional[str] = None,
comments: Optional[str] = None,
description: Optional[str] = None,
- **kwargs
- ):
+ **kwargs: Any
+ ) -> None:
"""
:keyword modification_event: Reason for the modification. Known values are:
"SmartGroupCreated", "StateChange", "AlertAdded", and "AlertRemoved".
@@ -2387,8 +2627,8 @@ def __init__(
*,
modifications: Optional[List["_models.SmartGroupModificationItem"]] = None,
next_link: Optional[str] = None,
- **kwargs
- ):
+ **kwargs: Any
+ ) -> None:
"""
:keyword modifications: Modification details.
:paramtype modifications: list[~azure.mgmt.alertsmanagement.models.SmartGroupModificationItem]
@@ -2416,8 +2656,8 @@ class SmartGroupsList(_serialization.Model):
}
def __init__(
- self, *, next_link: Optional[str] = None, value: Optional[List["_models.SmartGroup"]] = None, **kwargs
- ):
+ self, *, next_link: Optional[str] = None, value: Optional[List["_models.SmartGroup"]] = None, **kwargs: Any
+ ) -> None:
"""
:keyword next_link: URL to fetch the next set of alerts.
:paramtype next_link: str
@@ -2466,8 +2706,8 @@ def __init__(
last_modified_by: Optional[str] = None,
last_modified_by_type: Optional[Union[str, "_models.CreatedByType"]] = None,
last_modified_at: Optional[datetime.datetime] = None,
- **kwargs
- ):
+ **kwargs: Any
+ ) -> None:
"""
:keyword created_by: The identity that created the resource.
:paramtype created_by: str
@@ -2491,52 +2731,3 @@ def __init__(
self.last_modified_by = last_modified_by
self.last_modified_by_type = last_modified_by_type
self.last_modified_at = last_modified_at
-
-
-class WeeklyRecurrence(Recurrence):
- """Weekly recurrence object.
-
- All required parameters must be populated in order to send to Azure.
-
- :ivar recurrence_type: Specifies when the recurrence should be applied. Required. Known values
- are: "Daily", "Weekly", and "Monthly".
- :vartype recurrence_type: str or ~azure.mgmt.alertsmanagement.models.RecurrenceType
- :ivar start_time: Start time for recurrence.
- :vartype start_time: str
- :ivar end_time: End time for recurrence.
- :vartype end_time: str
- :ivar days_of_week: Specifies the values for weekly recurrence pattern. Required.
- :vartype days_of_week: list[str or ~azure.mgmt.alertsmanagement.models.DaysOfWeek]
- """
-
- _validation = {
- "recurrence_type": {"required": True},
- "days_of_week": {"required": True},
- }
-
- _attribute_map = {
- "recurrence_type": {"key": "recurrenceType", "type": "str"},
- "start_time": {"key": "startTime", "type": "str"},
- "end_time": {"key": "endTime", "type": "str"},
- "days_of_week": {"key": "daysOfWeek", "type": "[str]"},
- }
-
- def __init__(
- self,
- *,
- days_of_week: List[Union[str, "_models.DaysOfWeek"]],
- start_time: Optional[str] = None,
- end_time: Optional[str] = None,
- **kwargs
- ):
- """
- :keyword start_time: Start time for recurrence.
- :paramtype start_time: str
- :keyword end_time: End time for recurrence.
- :paramtype end_time: str
- :keyword days_of_week: Specifies the values for weekly recurrence pattern. Required.
- :paramtype days_of_week: list[str or ~azure.mgmt.alertsmanagement.models.DaysOfWeek]
- """
- super().__init__(start_time=start_time, end_time=end_time, **kwargs)
- self.recurrence_type: str = "Weekly"
- self.days_of_week = days_of_week
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/__init__.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/__init__.py
index c8dd1e48dcf0d..4691a31fa9983 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/__init__.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/__init__.py
@@ -5,23 +5,29 @@
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
+# pylint: disable=wrong-import-position
-from ._alert_processing_rules_operations import AlertProcessingRulesOperations
-from ._prometheus_rule_groups_operations import PrometheusRuleGroupsOperations
-from ._operations import Operations
-from ._alerts_operations import AlertsOperations
-from ._smart_groups_operations import SmartGroupsOperations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from ._patch import * # pylint: disable=unused-wildcard-import
+
+from ._prometheus_rule_groups_operations import PrometheusRuleGroupsOperations # type: ignore
+from ._operations import Operations # type: ignore
+from ._alerts_operations import AlertsOperations # type: ignore
+from ._smart_groups_operations import SmartGroupsOperations # type: ignore
+from ._alert_rule_recommendations_operations import AlertRuleRecommendationsOperations # type: ignore
from ._patch import __all__ as _patch_all
-from ._patch import * # pylint: disable=unused-wildcard-import
+from ._patch import *
from ._patch import patch_sdk as _patch_sdk
__all__ = [
- "AlertProcessingRulesOperations",
"PrometheusRuleGroupsOperations",
"Operations",
"AlertsOperations",
"SmartGroupsOperations",
+ "AlertRuleRecommendationsOperations",
]
-__all__.extend([p for p in _patch_all if p not in __all__])
+__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore
_patch_sdk()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_alert_processing_rules_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_alert_processing_rules_operations.py
deleted file mode 100644
index a9831118284f4..0000000000000
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_alert_processing_rules_operations.py
+++ /dev/null
@@ -1,818 +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) AutoRest Code Generator.
-# Changes may cause incorrect behavior and will be lost if the code is regenerated.
-# --------------------------------------------------------------------------
-import sys
-from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload
-
-from azure.core.exceptions import (
- ClientAuthenticationError,
- HttpResponseError,
- ResourceExistsError,
- ResourceNotFoundError,
- ResourceNotModifiedError,
- map_error,
-)
-from azure.core.paging import ItemPaged
-from azure.core.pipeline import PipelineResponse
-from azure.core.pipeline.transport import HttpResponse
-from azure.core.rest import HttpRequest
-from azure.core.tracing.decorator import distributed_trace
-from azure.core.utils import case_insensitive_dict
-from azure.mgmt.core.exceptions import ARMErrorFormat
-
-from .. import models as _models
-from .._serialization import Serializer
-from .._vendor import _convert_request, _format_url_section
-
-if sys.version_info >= (3, 8):
- from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports
-else:
- from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports
-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: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- accept = _headers.pop("Accept", "application/json")
-
- # Construct URL
- _url = kwargs.pop(
- "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/actionRules"
- )
- path_format_arguments = {
- "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str", min_length=1),
- }
-
- _url: str = _format_url_section(_url, **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: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- accept = _headers.pop("Accept", "application/json")
-
- # Construct URL
- _url = kwargs.pop(
- "template_url",
- "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/actionRules",
- ) # pylint: disable=line-too-long
- path_format_arguments = {
- "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str", min_length=1),
- "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
- }
-
- _url: str = _format_url_section(_url, **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_by_name_request(
- resource_group_name: str, alert_processing_rule_name: str, subscription_id: str, **kwargs: Any
-) -> HttpRequest:
- _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
- _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
-
- api_version: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- accept = _headers.pop("Accept", "application/json")
-
- # Construct URL
- _url = kwargs.pop(
- "template_url",
- "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/actionRules/{alertProcessingRuleName}",
- ) # pylint: disable=line-too-long
- path_format_arguments = {
- "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str", min_length=1),
- "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
- "alertProcessingRuleName": _SERIALIZER.url("alert_processing_rule_name", alert_processing_rule_name, "str"),
- }
-
- _url: str = _format_url_section(_url, **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, alert_processing_rule_name: str, subscription_id: str, **kwargs: Any
-) -> HttpRequest:
- _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
- _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
-
- api_version: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- 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.AlertsManagement/actionRules/{alertProcessingRuleName}",
- ) # pylint: disable=line-too-long
- path_format_arguments = {
- "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str", min_length=1),
- "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
- "alertProcessingRuleName": _SERIALIZER.url("alert_processing_rule_name", alert_processing_rule_name, "str"),
- }
-
- _url: str = _format_url_section(_url, **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, alert_processing_rule_name: str, subscription_id: str, **kwargs: Any
-) -> HttpRequest:
- _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
- _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
-
- api_version: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- accept = _headers.pop("Accept", "application/json")
-
- # Construct URL
- _url = kwargs.pop(
- "template_url",
- "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/actionRules/{alertProcessingRuleName}",
- ) # pylint: disable=line-too-long
- path_format_arguments = {
- "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str", min_length=1),
- "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
- "alertProcessingRuleName": _SERIALIZER.url("alert_processing_rule_name", alert_processing_rule_name, "str"),
- }
-
- _url: str = _format_url_section(_url, **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_update_request(
- resource_group_name: str, alert_processing_rule_name: str, subscription_id: str, **kwargs: Any
-) -> HttpRequest:
- _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
- _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
-
- api_version: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- 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.AlertsManagement/actionRules/{alertProcessingRuleName}",
- ) # pylint: disable=line-too-long
- path_format_arguments = {
- "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str", min_length=1),
- "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
- "alertProcessingRuleName": _SERIALIZER.url("alert_processing_rule_name", alert_processing_rule_name, "str"),
- }
-
- _url: str = _format_url_section(_url, **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)
-
-
-class AlertProcessingRulesOperations:
- """
- .. warning::
- **DO NOT** instantiate this class directly.
-
- Instead, you should access the following operations through
- :class:`~azure.mgmt.alertsmanagement.AlertsManagementClient`'s
- :attr:`alert_processing_rules` attribute.
- """
-
- models = _models
-
- def __init__(self, *args, **kwargs):
- input_args = list(args)
- self._client = input_args.pop(0) if input_args else kwargs.pop("client")
- self._config = input_args.pop(0) if input_args else kwargs.pop("config")
- self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer")
- self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer")
-
- @distributed_trace
- def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.AlertProcessingRule"]:
- """List all alert processing rules in a subscription.
-
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: An iterator like instance of either AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.alertsmanagement.models.AlertProcessingRule]
- :raises ~azure.core.exceptions.HttpResponseError:
- """
- _headers = kwargs.pop("headers", {}) or {}
- _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
-
- api_version: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- cls: ClsType[_models.AlertProcessingRulesList] = kwargs.pop("cls", None)
-
- error_map = {
- 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,
- template_url=self.list_by_subscription.metadata["url"],
- headers=_headers,
- params=_params,
- )
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
-
- else:
- request = HttpRequest("GET", next_link)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
- request.method = "GET"
- return request
-
- def extract_data(pipeline_response):
- deserialized = self._deserialize("AlertProcessingRulesList", 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)
-
- pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
- )
- response = pipeline_response.http_response
-
- if response.status_code not in [200]:
- map_error(status_code=response.status_code, response=response, error_map=error_map)
- 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)
-
- list_by_subscription.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/actionRules"
- }
-
- @distributed_trace
- def list_by_resource_group(
- self, resource_group_name: str, **kwargs: Any
- ) -> Iterable["_models.AlertProcessingRule"]:
- """List all alert processing rules in a resource group.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: An iterator like instance of either AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.alertsmanagement.models.AlertProcessingRule]
- :raises ~azure.core.exceptions.HttpResponseError:
- """
- _headers = kwargs.pop("headers", {}) or {}
- _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
-
- api_version: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- cls: ClsType[_models.AlertProcessingRulesList] = kwargs.pop("cls", None)
-
- error_map = {
- 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,
- template_url=self.list_by_resource_group.metadata["url"],
- headers=_headers,
- params=_params,
- )
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
-
- else:
- request = HttpRequest("GET", next_link)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
- request.method = "GET"
- return request
-
- def extract_data(pipeline_response):
- deserialized = self._deserialize("AlertProcessingRulesList", 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)
-
- pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
- )
- response = pipeline_response.http_response
-
- if response.status_code not in [200]:
- map_error(status_code=response.status_code, response=response, error_map=error_map)
- 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)
-
- list_by_resource_group.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/actionRules"
- }
-
- @distributed_trace
- def get_by_name(
- self, resource_group_name: str, alert_processing_rule_name: str, **kwargs: Any
- ) -> _models.AlertProcessingRule:
- """Get an alert processing rule by name.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name of the alert processing rule that needs to be
- fetched. Required.
- :type alert_processing_rule_name: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :raises ~azure.core.exceptions.HttpResponseError:
- """
- error_map = {
- 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: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- cls: ClsType[_models.AlertProcessingRule] = kwargs.pop("cls", None)
-
- request = build_get_by_name_request(
- resource_group_name=resource_group_name,
- alert_processing_rule_name=alert_processing_rule_name,
- subscription_id=self._config.subscription_id,
- api_version=api_version,
- template_url=self.get_by_name.metadata["url"],
- headers=_headers,
- params=_params,
- )
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
-
- pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
- )
-
- response = pipeline_response.http_response
-
- if response.status_code not in [200]:
- map_error(status_code=response.status_code, response=response, error_map=error_map)
- error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
- raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
-
- response_headers = {}
- response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
-
- deserialized = self._deserialize("AlertProcessingRule", pipeline_response)
-
- if cls:
- return cls(pipeline_response, deserialized, response_headers)
-
- return deserialized
-
- get_by_name.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/actionRules/{alertProcessingRuleName}"
- }
-
- @overload
- def create_or_update(
- self,
- resource_group_name: str,
- alert_processing_rule_name: str,
- alert_processing_rule: _models.AlertProcessingRule,
- *,
- content_type: str = "application/json",
- **kwargs: Any
- ) -> _models.AlertProcessingRule:
- """Create or update an alert processing rule.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name of the alert processing rule that needs to be
- created/updated. Required.
- :type alert_processing_rule_name: str
- :param alert_processing_rule: Alert processing rule to be created/updated. Required.
- :type alert_processing_rule: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
- Default value is "application/json".
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :raises ~azure.core.exceptions.HttpResponseError:
- """
-
- @overload
- def create_or_update(
- self,
- resource_group_name: str,
- alert_processing_rule_name: str,
- alert_processing_rule: IO,
- *,
- content_type: str = "application/json",
- **kwargs: Any
- ) -> _models.AlertProcessingRule:
- """Create or update an alert processing rule.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name of the alert processing rule that needs to be
- created/updated. Required.
- :type alert_processing_rule_name: str
- :param alert_processing_rule: Alert processing rule to be created/updated. Required.
- :type alert_processing_rule: IO
- :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
- Default value is "application/json".
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :raises ~azure.core.exceptions.HttpResponseError:
- """
-
- @distributed_trace
- def create_or_update(
- self,
- resource_group_name: str,
- alert_processing_rule_name: str,
- alert_processing_rule: Union[_models.AlertProcessingRule, IO],
- **kwargs: Any
- ) -> _models.AlertProcessingRule:
- """Create or update an alert processing rule.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name of the alert processing rule that needs to be
- created/updated. Required.
- :type alert_processing_rule_name: str
- :param alert_processing_rule: Alert processing rule to be created/updated. Is either a model
- type or a IO type. Required.
- :type alert_processing_rule: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule or IO
- :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
- Default value is None.
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :raises ~azure.core.exceptions.HttpResponseError:
- """
- error_map = {
- 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: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
- cls: ClsType[_models.AlertProcessingRule] = kwargs.pop("cls", None)
-
- content_type = content_type or "application/json"
- _json = None
- _content = None
- if isinstance(alert_processing_rule, (IO, bytes)):
- _content = alert_processing_rule
- else:
- _json = self._serialize.body(alert_processing_rule, "AlertProcessingRule")
-
- request = build_create_or_update_request(
- resource_group_name=resource_group_name,
- alert_processing_rule_name=alert_processing_rule_name,
- subscription_id=self._config.subscription_id,
- api_version=api_version,
- content_type=content_type,
- json=_json,
- content=_content,
- template_url=self.create_or_update.metadata["url"],
- headers=_headers,
- params=_params,
- )
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
-
- pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **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)
-
- response_headers = {}
- if response.status_code == 200:
- response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
-
- deserialized = self._deserialize("AlertProcessingRule", pipeline_response)
-
- if response.status_code == 201:
- response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
-
- deserialized = self._deserialize("AlertProcessingRule", pipeline_response)
-
- if cls:
- return cls(pipeline_response, deserialized, response_headers) # type: ignore
-
- return deserialized # type: ignore
-
- create_or_update.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/actionRules/{alertProcessingRuleName}"
- }
-
- @distributed_trace
- def delete( # pylint: disable=inconsistent-return-statements
- self, resource_group_name: str, alert_processing_rule_name: str, **kwargs: Any
- ) -> None:
- """Delete an alert processing rule.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name of the alert processing rule that needs to be
- deleted. Required.
- :type alert_processing_rule_name: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: None or the result of cls(response)
- :rtype: None
- :raises ~azure.core.exceptions.HttpResponseError:
- """
- error_map = {
- 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: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- cls: ClsType[None] = kwargs.pop("cls", None)
-
- request = build_delete_request(
- resource_group_name=resource_group_name,
- alert_processing_rule_name=alert_processing_rule_name,
- subscription_id=self._config.subscription_id,
- api_version=api_version,
- template_url=self.delete.metadata["url"],
- headers=_headers,
- params=_params,
- )
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
-
- pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **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)
-
- response_headers = {}
- if response.status_code == 200:
- response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
-
- if response.status_code == 204:
- response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
-
- if cls:
- return cls(pipeline_response, None, response_headers)
-
- delete.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/actionRules/{alertProcessingRuleName}"
- }
-
- @overload
- def update(
- self,
- resource_group_name: str,
- alert_processing_rule_name: str,
- alert_processing_rule_patch: _models.PatchObject,
- *,
- content_type: str = "application/json",
- **kwargs: Any
- ) -> _models.AlertProcessingRule:
- """Enable, disable, or update tags for an alert processing rule.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name that needs to be updated. Required.
- :type alert_processing_rule_name: str
- :param alert_processing_rule_patch: Parameters supplied to the operation. Required.
- :type alert_processing_rule_patch: ~azure.mgmt.alertsmanagement.models.PatchObject
- :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
- Default value is "application/json".
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :raises ~azure.core.exceptions.HttpResponseError:
- """
-
- @overload
- def update(
- self,
- resource_group_name: str,
- alert_processing_rule_name: str,
- alert_processing_rule_patch: IO,
- *,
- content_type: str = "application/json",
- **kwargs: Any
- ) -> _models.AlertProcessingRule:
- """Enable, disable, or update tags for an alert processing rule.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name that needs to be updated. Required.
- :type alert_processing_rule_name: str
- :param alert_processing_rule_patch: Parameters supplied to the operation. Required.
- :type alert_processing_rule_patch: IO
- :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
- Default value is "application/json".
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :raises ~azure.core.exceptions.HttpResponseError:
- """
-
- @distributed_trace
- def update(
- self,
- resource_group_name: str,
- alert_processing_rule_name: str,
- alert_processing_rule_patch: Union[_models.PatchObject, IO],
- **kwargs: Any
- ) -> _models.AlertProcessingRule:
- """Enable, disable, or update tags for an alert processing rule.
-
- :param resource_group_name: Resource group name where the resource is created. Required.
- :type resource_group_name: str
- :param alert_processing_rule_name: The name that needs to be updated. Required.
- :type alert_processing_rule_name: str
- :param alert_processing_rule_patch: Parameters supplied to the operation. Is either a model
- type or a IO type. Required.
- :type alert_processing_rule_patch: ~azure.mgmt.alertsmanagement.models.PatchObject or IO
- :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
- Default value is None.
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
- :return: AlertProcessingRule or the result of cls(response)
- :rtype: ~azure.mgmt.alertsmanagement.models.AlertProcessingRule
- :raises ~azure.core.exceptions.HttpResponseError:
- """
- error_map = {
- 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: Literal["2021-08-08"] = kwargs.pop("api_version", _params.pop("api-version", "2021-08-08"))
- content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
- cls: ClsType[_models.AlertProcessingRule] = kwargs.pop("cls", None)
-
- content_type = content_type or "application/json"
- _json = None
- _content = None
- if isinstance(alert_processing_rule_patch, (IO, bytes)):
- _content = alert_processing_rule_patch
- else:
- _json = self._serialize.body(alert_processing_rule_patch, "PatchObject")
-
- request = build_update_request(
- resource_group_name=resource_group_name,
- alert_processing_rule_name=alert_processing_rule_name,
- subscription_id=self._config.subscription_id,
- api_version=api_version,
- content_type=content_type,
- json=_json,
- content=_content,
- template_url=self.update.metadata["url"],
- headers=_headers,
- params=_params,
- )
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
-
- pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
- )
-
- response = pipeline_response.http_response
-
- if response.status_code not in [200]:
- map_error(status_code=response.status_code, response=response, error_map=error_map)
- error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
- raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
-
- response_headers = {}
- response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
-
- deserialized = self._deserialize("AlertProcessingRule", pipeline_response)
-
- if cls:
- return cls(pipeline_response, deserialized, response_headers)
-
- return deserialized
-
- update.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/actionRules/{alertProcessingRuleName}"
- }
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_alert_rule_recommendations_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_alert_rule_recommendations_operations.py
new file mode 100644
index 0000000000000..334b8b717a6af
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_alert_rule_recommendations_operations.py
@@ -0,0 +1,247 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) AutoRest Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+import sys
+from typing import Any, Callable, Dict, Iterable, Optional, TypeVar
+
+from azure.core.exceptions import (
+ ClientAuthenticationError,
+ HttpResponseError,
+ ResourceExistsError,
+ ResourceNotFoundError,
+ ResourceNotModifiedError,
+ map_error,
+)
+from azure.core.paging import ItemPaged
+from azure.core.pipeline import PipelineResponse
+from azure.core.rest import HttpRequest, HttpResponse
+from azure.core.tracing.decorator import distributed_trace
+from azure.core.utils import case_insensitive_dict
+from azure.mgmt.core.exceptions import ARMErrorFormat
+
+from .. import models as _models
+from .._serialization import Serializer
+
+if sys.version_info >= (3, 9):
+ from collections.abc import MutableMapping
+else:
+ from typing import MutableMapping # type: ignore
+T = TypeVar("T")
+ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]]
+
+_SERIALIZER = Serializer()
+_SERIALIZER.client_side_validation = False
+
+
+def build_list_by_resource_request(resource_uri: str, **kwargs: Any) -> HttpRequest:
+ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+ _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-01-preview"))
+ accept = _headers.pop("Accept", "application/json")
+
+ # Construct URL
+ _url = kwargs.pop("template_url", "/{resourceUri}/providers/Microsoft.AlertsManagement/alertRuleRecommendations")
+ path_format_arguments = {
+ "resourceUri": _SERIALIZER.url("resource_uri", resource_uri, "str", skip_quote=True),
+ }
+
+ _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_target_type_request(subscription_id: str, *, target_type: str, **kwargs: Any) -> HttpRequest:
+ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+ _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-01-preview"))
+ accept = _headers.pop("Accept", "application/json")
+
+ # Construct URL
+ _url = kwargs.pop(
+ "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alertRuleRecommendations"
+ ) # pylint: disable=line-too-long
+ path_format_arguments = {
+ "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str", min_length=1),
+ }
+
+ _url: str = _url.format(**path_format_arguments) # type: ignore
+
+ # Construct parameters
+ _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
+ _params["targetType"] = _SERIALIZER.query("target_type", target_type, "str")
+
+ # Construct headers
+ _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+
+ return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
+
+
+class AlertRuleRecommendationsOperations:
+ """
+ .. warning::
+ **DO NOT** instantiate this class directly.
+
+ Instead, you should access the following operations through
+ :class:`~azure.mgmt.alertsmanagement.AlertsManagementClient`'s
+ :attr:`alert_rule_recommendations` attribute.
+ """
+
+ models = _models
+
+ def __init__(self, *args, **kwargs):
+ input_args = list(args)
+ self._client = input_args.pop(0) if input_args else kwargs.pop("client")
+ self._config = input_args.pop(0) if input_args else kwargs.pop("config")
+ self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer")
+ self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer")
+
+ @distributed_trace
+ def list_by_resource(self, resource_uri: str, **kwargs: Any) -> Iterable["_models.AlertRuleRecommendationResource"]:
+ """Retrieve alert rule recommendations for a resource.
+
+ :param resource_uri: The identifier of the resource. Required.
+ :type resource_uri: str
+ :return: An iterator like instance of either AlertRuleRecommendationResource or the result of
+ cls(response)
+ :rtype:
+ ~azure.core.paging.ItemPaged[~azure.mgmt.alertsmanagement.models.AlertRuleRecommendationResource]
+ :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", "2023-08-01-preview"))
+ cls: ClsType[_models.AlertRuleRecommendationsListResponse] = 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_request(
+ resource_uri=resource_uri,
+ api_version=api_version,
+ headers=_headers,
+ params=_params,
+ )
+ _request.url = self._client.format_url(_request.url)
+
+ else:
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
+
+ def extract_data(pipeline_response):
+ deserialized = self._deserialize("AlertRuleRecommendationsListResponse", 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_target_type(
+ self, target_type: str, **kwargs: Any
+ ) -> Iterable["_models.AlertRuleRecommendationResource"]:
+ """Retrieve alert rule recommendations for a target type.
+
+ :param target_type: The recommendations target type. Required.
+ :type target_type: str
+ :return: An iterator like instance of either AlertRuleRecommendationResource or the result of
+ cls(response)
+ :rtype:
+ ~azure.core.paging.ItemPaged[~azure.mgmt.alertsmanagement.models.AlertRuleRecommendationResource]
+ :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", "2023-08-01-preview"))
+ cls: ClsType[_models.AlertRuleRecommendationsListResponse] = 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_target_type_request(
+ subscription_id=self._config.subscription_id,
+ target_type=target_type,
+ api_version=api_version,
+ headers=_headers,
+ params=_params,
+ )
+ _request.url = self._client.format_url(_request.url)
+
+ else:
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
+
+ def extract_data(pipeline_response):
+ deserialized = self._deserialize("AlertRuleRecommendationsListResponse", 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)
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_alerts_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_alerts_operations.py
index f4835f11fa5bb..6e49384802884 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_alerts_operations.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_alerts_operations.py
@@ -6,6 +6,7 @@
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
+from io import IOBase
import sys
from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload
@@ -19,20 +20,18 @@
)
from azure.core.paging import ItemPaged
from azure.core.pipeline import PipelineResponse
-from azure.core.pipeline.transport import HttpResponse
-from azure.core.rest import HttpRequest
+from azure.core.rest import HttpRequest, HttpResponse
from azure.core.tracing.decorator import distributed_trace
from azure.core.utils import case_insensitive_dict
from azure.mgmt.core.exceptions import ARMErrorFormat
from .. import models as _models
from .._serialization import Serializer
-from .._vendor import _convert_request, _format_url_section
-if sys.version_info >= (3, 8):
- from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports
+if sys.version_info >= (3, 9):
+ from collections.abc import MutableMapping
else:
- from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports
+ from typing import MutableMapping # type: ignore
T = TypeVar("T")
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]]
@@ -44,9 +43,7 @@ def build_meta_data_request(*, identifier: Union[str, _models.Identifier], **kwa
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -63,7 +60,7 @@ def build_meta_data_request(*, identifier: Union[str, _models.Identifier], **kwa
def build_get_all_request(
- subscription_id: str,
+ scope: str,
*,
target_resource: Optional[str] = None,
target_resource_type: Optional[str] = None,
@@ -87,18 +84,16 @@ def build_get_all_request(
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
- _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alerts")
+ _url = kwargs.pop("template_url", "/{scope}/providers/Microsoft.AlertsManagement/alerts")
path_format_arguments = {
- "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str", min_length=1),
+ "scope": _SERIALIZER.url("scope", scope, "str", skip_quote=True),
}
- _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore
+ _url: str = _url.format(**path_format_arguments) # type: ignore
# Construct parameters
if target_resource is not None:
@@ -143,25 +138,21 @@ def build_get_all_request(
return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
-def build_get_by_id_request(alert_id: str, subscription_id: str, **kwargs: Any) -> HttpRequest:
+def build_get_by_id_request(scope: str, alert_id: str, **kwargs: Any) -> HttpRequest:
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
- _url = kwargs.pop(
- "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alerts/{alertId}"
- ) # pylint: disable=line-too-long
+ _url = kwargs.pop("template_url", "/{scope}/providers/Microsoft.AlertsManagement/alerts/{alertId}")
path_format_arguments = {
- "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str", min_length=1),
+ "scope": _SERIALIZER.url("scope", scope, "str", skip_quote=True),
"alertId": _SERIALIZER.url("alert_id", alert_id, "str"),
}
- _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore
+ _url: str = _url.format(**path_format_arguments) # type: ignore
# Construct parameters
_params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -173,28 +164,23 @@ def build_get_by_id_request(alert_id: str, subscription_id: str, **kwargs: Any)
def build_change_state_request(
- alert_id: str, subscription_id: str, *, new_state: Union[str, _models.AlertState], **kwargs: Any
+ scope: str, alert_id: str, *, new_state: Union[str, _models.AlertState], **kwargs: Any
) -> HttpRequest:
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
accept = _headers.pop("Accept", "application/json")
# Construct URL
- _url = kwargs.pop(
- "template_url",
- "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alerts/{alertId}/changestate",
- ) # pylint: disable=line-too-long
+ _url = kwargs.pop("template_url", "/{scope}/providers/Microsoft.AlertsManagement/alerts/{alertId}/changestate")
path_format_arguments = {
- "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str", min_length=1),
+ "scope": _SERIALIZER.url("scope", scope, "str", skip_quote=True),
"alertId": _SERIALIZER.url("alert_id", alert_id, "str"),
}
- _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore
+ _url: str = _url.format(**path_format_arguments) # type: ignore
# Construct parameters
_params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -208,25 +194,21 @@ def build_change_state_request(
return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
-def build_get_history_request(alert_id: str, subscription_id: str, **kwargs: Any) -> HttpRequest:
+def build_get_history_request(scope: str, alert_id: str, **kwargs: Any) -> HttpRequest:
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
- _url = kwargs.pop(
- "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alerts/{alertId}/history"
- ) # pylint: disable=line-too-long
+ _url = kwargs.pop("template_url", "/{scope}/providers/Microsoft.AlertsManagement/alerts/{alertId}/history")
path_format_arguments = {
- "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str", min_length=1),
+ "scope": _SERIALIZER.url("scope", scope, "str", skip_quote=True),
"alertId": _SERIALIZER.url("alert_id", alert_id, "str"),
}
- _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore
+ _url: str = _url.format(**path_format_arguments) # type: ignore
# Construct parameters
_params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -238,7 +220,7 @@ def build_get_history_request(alert_id: str, subscription_id: str, **kwargs: Any
def build_get_summary_request(
- subscription_id: str,
+ scope: str,
*,
groupby: Union[str, _models.AlertsSummaryGroupByFields],
include_smart_groups_count: Optional[bool] = None,
@@ -257,20 +239,16 @@ def build_get_summary_request(
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
- _url = kwargs.pop(
- "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alertsSummary"
- )
+ _url = kwargs.pop("template_url", "/{scope}/providers/Microsoft.AlertsManagement/alertsSummary")
path_format_arguments = {
- "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str", min_length=1),
+ "scope": _SERIALIZER.url("scope", scope, "str", skip_quote=True),
}
- _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore
+ _url: str = _url.format(**path_format_arguments) # type: ignore
# Construct parameters
_params["groupby"] = _SERIALIZER.query("groupby", groupby, "str")
@@ -306,6 +284,58 @@ def build_get_summary_request(
return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
+def build_list_enrichments_request(scope: str, alert_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", "2024-01-01-preview"))
+ accept = _headers.pop("Accept", "application/json")
+
+ # Construct URL
+ _url = kwargs.pop("template_url", "/{scope}/providers/Microsoft.AlertsManagement/alerts/{alertId}/enrichments")
+ path_format_arguments = {
+ "scope": _SERIALIZER.url("scope", scope, "str", skip_quote=True),
+ "alertId": _SERIALIZER.url("alert_id", alert_id, "str"),
+ }
+
+ _url: str = _url.format(**path_format_arguments) # type: ignore
+
+ # Construct parameters
+ _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
+
+ # Construct headers
+ _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+
+ return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
+
+
+def build_get_enrichments_request(scope: str, alert_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", "2024-01-01-preview"))
+ accept = _headers.pop("Accept", "application/json")
+
+ # Construct URL
+ _url = kwargs.pop(
+ "template_url", "/{scope}/providers/Microsoft.AlertsManagement/alerts/{alertId}/enrichments/default"
+ )
+ path_format_arguments = {
+ "scope": _SERIALIZER.url("scope", scope, "str", skip_quote=True),
+ "alertId": _SERIALIZER.url("alert_id", alert_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)
+
+
class AlertsOperations:
"""
.. warning::
@@ -332,12 +362,11 @@ def meta_data(self, identifier: Union[str, _models.Identifier], **kwargs: Any) -
:param identifier: Identification of the information to be retrieved by API call.
"MonitorServiceList" Required.
:type identifier: str or ~azure.mgmt.alertsmanagement.models.Identifier
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: AlertsMetaData or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.AlertsMetaData
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -348,44 +377,40 @@ def meta_data(self, identifier: Union[str, _models.Identifier], **kwargs: Any) -
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
cls: ClsType[_models.AlertsMetaData] = kwargs.pop("cls", None)
- request = build_meta_data_request(
+ _request = build_meta_data_request(
identifier=identifier,
api_version=api_version,
- template_url=self.meta_data.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated2, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("AlertsMetaData", pipeline_response)
+ deserialized = self._deserialize("AlertsMetaData", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- return deserialized
-
- meta_data.metadata = {"url": "/providers/Microsoft.AlertsManagement/alertsMetaData"}
+ return deserialized # type: ignore
@distributed_trace
def get_all(
self,
+ scope: str,
target_resource: Optional[str] = None,
target_resource_type: Optional[str] = None,
target_resource_group: Optional[str] = None,
@@ -409,6 +434,8 @@ def get_all(
(e.g. time range). The results can then be sorted on the basis specific fields, with the
default being lastModifiedDateTime.
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
:param target_resource: Filter by target resource( which is full ARM ID) Default value is
select all. Default value is None.
:type target_resource: str
@@ -422,7 +449,7 @@ def get_all(
value is select all. Known values are: "Application Insights", "ActivityLog Administrative",
"ActivityLog Security", "ActivityLog Recommendation", "ActivityLog Policy", "ActivityLog
Autoscale", "Log Analytics", "Nagios", "Platform", "SCOM", "ServiceHealth", "SmartDetector",
- "VM Insights", and "Zabbix". Default value is None.
+ "VM Insights", "Zabbix", and "Resource Health". Default value is None.
:type monitor_service: str or ~azure.mgmt.alertsmanagement.models.MonitorService
:param monitor_condition: Filter by monitor condition which is either 'Fired' or 'Resolved'.
Default value is to select all. Known values are: "Fired" and "Resolved". Default value is
@@ -472,7 +499,6 @@ def get_all(
values is within 30 days from query time. Either timeRange or customTimeRange could be used
but not both. Default is none. Default value is None.
:type custom_time_range: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either Alert or the result of cls(response)
:rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.alertsmanagement.models.Alert]
:raises ~azure.core.exceptions.HttpResponseError:
@@ -480,12 +506,10 @@ def get_all(
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
cls: ClsType[_models.AlertsList] = kwargs.pop("cls", None)
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -496,8 +520,8 @@ def get_all(
def prepare_request(next_link=None):
if not next_link:
- request = build_get_all_request(
- subscription_id=self._config.subscription_id,
+ _request = build_get_all_request(
+ scope=scope,
target_resource=target_resource,
target_resource_type=target_resource_type,
target_resource_group=target_resource_group,
@@ -516,19 +540,16 @@ def prepare_request(next_link=None):
time_range=time_range,
custom_time_range=custom_time_range,
api_version=api_version,
- template_url=self.get_all.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
else:
- request = HttpRequest("GET", next_link)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
- request.method = "GET"
- return request
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
def extract_data(pipeline_response):
deserialized = self._deserialize("AlertsList", pipeline_response)
@@ -538,38 +559,38 @@ def extract_data(pipeline_response):
return deserialized.next_link or None, iter(list_of_elem)
def get_next(next_link=None):
- request = prepare_request(next_link)
+ _request = prepare_request(next_link)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated2, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
return pipeline_response
return ItemPaged(get_next, extract_data)
- get_all.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alerts"}
-
@distributed_trace
- def get_by_id(self, alert_id: str, **kwargs: Any) -> _models.Alert:
+ def get_by_id(self, scope: str, alert_id: str, **kwargs: Any) -> _models.Alert:
"""Get a specific alert.
Get information related to a specific alert.
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
:param alert_id: Unique ID of an alert instance. Required.
:type alert_id: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: Alert or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.Alert
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -580,47 +601,41 @@ def get_by_id(self, alert_id: str, **kwargs: Any) -> _models.Alert:
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
cls: ClsType[_models.Alert] = kwargs.pop("cls", None)
- request = build_get_by_id_request(
+ _request = build_get_by_id_request(
+ scope=scope,
alert_id=alert_id,
- subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.get_by_id.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated2, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("Alert", pipeline_response)
+ deserialized = self._deserialize("Alert", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
-
- return deserialized
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- get_by_id.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alerts/{alertId}"
- }
+ return deserialized # type: ignore
@overload
def change_state(
self,
+ scope: str,
alert_id: str,
new_state: Union[str, _models.AlertState],
comment: Optional[_models.Comments] = None,
@@ -630,6 +645,8 @@ def change_state(
) -> _models.Alert:
"""Change the state of an alert.
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
:param alert_id: Unique ID of an alert instance. Required.
:type alert_id: str
:param new_state: New state of the alert. Known values are: "New", "Acknowledged", and
@@ -640,7 +657,6 @@ def change_state(
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: Alert or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.Alert
:raises ~azure.core.exceptions.HttpResponseError:
@@ -649,26 +665,28 @@ def change_state(
@overload
def change_state(
self,
+ scope: str,
alert_id: str,
new_state: Union[str, _models.AlertState],
- comment: Optional[IO] = None,
+ comment: Optional[IO[bytes]] = None,
*,
content_type: str = "application/json",
**kwargs: Any
) -> _models.Alert:
"""Change the state of an alert.
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
:param alert_id: Unique ID of an alert instance. Required.
:type alert_id: str
:param new_state: New state of the alert. Known values are: "New", "Acknowledged", and
"Closed". Required.
:type new_state: str or ~azure.mgmt.alertsmanagement.models.AlertState
:param comment: reason of change alert state. Default value is None.
- :type comment: IO
+ :type comment: IO[bytes]
:keyword content_type: Body Parameter content-type. Content type parameter for binary body.
Default value is "application/json".
:paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: Alert or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.Alert
:raises ~azure.core.exceptions.HttpResponseError:
@@ -677,30 +695,29 @@ def change_state(
@distributed_trace
def change_state(
self,
+ scope: str,
alert_id: str,
new_state: Union[str, _models.AlertState],
- comment: Optional[Union[_models.Comments, IO]] = None,
+ comment: Optional[Union[_models.Comments, IO[bytes]]] = None,
**kwargs: Any
) -> _models.Alert:
"""Change the state of an alert.
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
:param alert_id: Unique ID of an alert instance. Required.
:type alert_id: str
:param new_state: New state of the alert. Known values are: "New", "Acknowledged", and
"Closed". Required.
:type new_state: str or ~azure.mgmt.alertsmanagement.models.AlertState
- :param comment: reason of change alert state. Is either a model type or a IO type. Default
- value is None.
- :type comment: ~azure.mgmt.alertsmanagement.models.Comments or IO
- :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
+ :param comment: reason of change alert state. Is either a Comments type or a IO[bytes] type.
Default value is None.
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
+ :type comment: ~azure.mgmt.alertsmanagement.models.Comments or IO[bytes]
:return: Alert or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.Alert
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -711,16 +728,14 @@ def change_state(
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
cls: ClsType[_models.Alert] = kwargs.pop("cls", None)
content_type = content_type or "application/json"
_json = None
_content = None
- if isinstance(comment, (IO, bytes)):
+ if isinstance(comment, (IOBase, bytes)):
_content = comment
else:
if comment is not None:
@@ -728,56 +743,52 @@ def change_state(
else:
_json = None
- request = build_change_state_request(
+ _request = build_change_state_request(
+ scope=scope,
alert_id=alert_id,
- subscription_id=self._config.subscription_id,
new_state=new_state,
api_version=api_version,
content_type=content_type,
json=_json,
content=_content,
- template_url=self.change_state.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated2, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("Alert", pipeline_response)
+ deserialized = self._deserialize("Alert", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- return deserialized
-
- change_state.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alerts/{alertId}/changestate"
- }
+ return deserialized # type: ignore
@distributed_trace
- def get_history(self, alert_id: str, **kwargs: Any) -> _models.AlertModification:
+ def get_history(self, scope: str, alert_id: str, **kwargs: Any) -> _models.AlertModification:
"""Get the history of an alert, which captures any monitor condition changes (Fired/Resolved) and
alert state changes (New/Acknowledged/Closed).
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
:param alert_id: Unique ID of an alert instance. Required.
:type alert_id: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: AlertModification or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.AlertModification
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -788,47 +799,41 @@ def get_history(self, alert_id: str, **kwargs: Any) -> _models.AlertModification
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
cls: ClsType[_models.AlertModification] = kwargs.pop("cls", None)
- request = build_get_history_request(
+ _request = build_get_history_request(
+ scope=scope,
alert_id=alert_id,
- subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.get_history.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated2, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("AlertModification", pipeline_response)
+ deserialized = self._deserialize("AlertModification", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
-
- return deserialized
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- get_history.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alerts/{alertId}/history"
- }
+ return deserialized # type: ignore
@distributed_trace
def get_summary(
self,
+ scope: str,
groupby: Union[str, _models.AlertsSummaryGroupByFields],
include_smart_groups_count: Optional[bool] = None,
target_resource: Optional[str] = None,
@@ -846,6 +851,8 @@ def get_summary(
"""Get a summarized count of your alerts grouped by various parameters (e.g. grouping by
'Severity' returns the count of alerts for each severity).
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
:param groupby: This parameter allows the result set to be grouped by input fields (Maximum 2
comma separated fields supported). For example, groupby=severity or
groupby=severity,alertstate. Known values are: "severity", "alertState", "monitorCondition",
@@ -867,7 +874,7 @@ def get_summary(
value is select all. Known values are: "Application Insights", "ActivityLog Administrative",
"ActivityLog Security", "ActivityLog Recommendation", "ActivityLog Policy", "ActivityLog
Autoscale", "Log Analytics", "Nagios", "Platform", "SCOM", "ServiceHealth", "SmartDetector",
- "VM Insights", and "Zabbix". Default value is None.
+ "VM Insights", "Zabbix", and "Resource Health". Default value is None.
:type monitor_service: str or ~azure.mgmt.alertsmanagement.models.MonitorService
:param monitor_condition: Filter by monitor condition which is either 'Fired' or 'Resolved'.
Default value is to select all. Known values are: "Fired" and "Resolved". Default value is
@@ -890,12 +897,11 @@ def get_summary(
values is within 30 days from query time. Either timeRange or customTimeRange could be used
but not both. Default is none. Default value is None.
:type custom_time_range: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: AlertsSummary or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.AlertsSummary
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -906,13 +912,11 @@ def get_summary(
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
cls: ClsType[_models.AlertsSummary] = kwargs.pop("cls", None)
- request = build_get_summary_request(
- subscription_id=self._config.subscription_id,
+ _request = build_get_summary_request(
+ scope=scope,
groupby=groupby,
include_smart_groups_count=include_smart_groups_count,
target_resource=target_resource,
@@ -926,29 +930,151 @@ def get_summary(
time_range=time_range,
custom_time_range=custom_time_range,
api_version=api_version,
- template_url=self.get_summary.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated2, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("AlertsSummary", pipeline_response)
+ deserialized = self._deserialize("AlertsSummary", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
+ return cls(pipeline_response, deserialized, {}) # type: ignore
+
+ return deserialized # type: ignore
+
+ @distributed_trace
+ def list_enrichments(self, scope: str, alert_id: str, **kwargs: Any) -> Iterable["_models.AlertEnrichmentResponse"]:
+ """List the enrichments of an alert. It returns a collection of one object named default.
+
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
+ :param alert_id: Unique ID of an alert instance. Required.
+ :type alert_id: str
+ :return: An iterator like instance of either AlertEnrichmentResponse or the result of
+ cls(response)
+ :rtype:
+ ~azure.core.paging.ItemPaged[~azure.mgmt.alertsmanagement.models.AlertEnrichmentResponse]
+ :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", "2024-01-01-preview"))
+ cls: ClsType[_models.AlertEnrichmentsList] = 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_enrichments_request(
+ scope=scope,
+ alert_id=alert_id,
+ api_version=api_version,
+ headers=_headers,
+ params=_params,
+ )
+ _request.url = self._client.format_url(_request.url)
+
+ else:
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
+
+ def extract_data(pipeline_response):
+ deserialized = self._deserialize("AlertEnrichmentsList", pipeline_response)
+ list_of_elem = deserialized.value
+ if cls:
+ list_of_elem = cls(list_of_elem) # type: ignore
+ return 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.ErrorResponseAutoGenerated2, pipeline_response)
+ raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- return deserialized
+ return pipeline_response
+
+ return ItemPaged(get_next, extract_data)
+
+ @distributed_trace
+ def get_enrichments(self, scope: str, alert_id: str, **kwargs: Any) -> _models.AlertEnrichmentResponse:
+ """Get the enrichments of an alert.
+
+ :param scope: scope here is resourceId for which alert is created. Required.
+ :type scope: str
+ :param alert_id: Unique ID of an alert instance. Required.
+ :type alert_id: str
+ :return: AlertEnrichmentResponse or the result of cls(response)
+ :rtype: ~azure.mgmt.alertsmanagement.models.AlertEnrichmentResponse
+ :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", "2024-01-01-preview"))
+ cls: ClsType[_models.AlertEnrichmentResponse] = kwargs.pop("cls", None)
+
+ _request = build_get_enrichments_request(
+ scope=scope,
+ alert_id=alert_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.ErrorResponseAutoGenerated2, pipeline_response)
+ raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
+
+ deserialized = self._deserialize("AlertEnrichmentResponse", pipeline_response.http_response)
+
+ if cls:
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- get_summary.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/alertsSummary"}
+ return deserialized # type: ignore
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_operations.py
index a607bf0f4a25d..118364a3cfc76 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_operations.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_operations.py
@@ -1,4 +1,3 @@
-# pylint: disable=too-many-lines
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
@@ -19,20 +18,18 @@
)
from azure.core.paging import ItemPaged
from azure.core.pipeline import PipelineResponse
-from azure.core.pipeline.transport import HttpResponse
-from azure.core.rest import HttpRequest
+from azure.core.rest import HttpRequest, HttpResponse
from azure.core.tracing.decorator import distributed_trace
from azure.core.utils import case_insensitive_dict
from azure.mgmt.core.exceptions import ARMErrorFormat
from .. import models as _models
from .._serialization import Serializer
-from .._vendor import _convert_request
-if sys.version_info >= (3, 8):
- from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports
+if sys.version_info >= (3, 9):
+ from collections.abc import MutableMapping
else:
- from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports
+ from typing import MutableMapping # type: ignore
T = TypeVar("T")
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]]
@@ -44,9 +41,7 @@ def build_list_request(**kwargs: Any) -> HttpRequest:
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -84,7 +79,6 @@ def __init__(self, *args, **kwargs):
def list(self, **kwargs: Any) -> Iterable["_models.Operation"]:
"""List all operations available through Azure Alerts Management Resource Provider.
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either Operation or the result of cls(response)
:rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.alertsmanagement.models.Operation]
:raises ~azure.core.exceptions.HttpResponseError:
@@ -92,12 +86,10 @@ def list(self, **kwargs: Any) -> Iterable["_models.Operation"]:
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-01-01-preview"))
cls: ClsType[_models.OperationsList] = kwargs.pop("cls", None)
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -108,21 +100,18 @@ def list(self, **kwargs: Any) -> Iterable["_models.Operation"]:
def prepare_request(next_link=None):
if not next_link:
- request = build_list_request(
+ _request = build_list_request(
api_version=api_version,
- template_url=self.list.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
else:
- request = HttpRequest("GET", next_link)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
- request.method = "GET"
- return request
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
def extract_data(pipeline_response):
deserialized = self._deserialize("OperationsList", pipeline_response)
@@ -132,20 +121,19 @@ def extract_data(pipeline_response):
return deserialized.next_link or None, iter(list_of_elem)
def get_next(next_link=None):
- request = prepare_request(next_link)
+ _request = prepare_request(next_link)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated2, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
return pipeline_response
return ItemPaged(get_next, extract_data)
-
- list.metadata = {"url": "/providers/Microsoft.AlertsManagement/operations"}
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_prometheus_rule_groups_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_prometheus_rule_groups_operations.py
index 02a44a95f2410..66828190299e1 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_prometheus_rule_groups_operations.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_prometheus_rule_groups_operations.py
@@ -1,4 +1,3 @@
-# pylint: disable=too-many-lines
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
@@ -6,6 +5,7 @@
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
+from io import IOBase
import sys
from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload
@@ -19,20 +19,18 @@
)
from azure.core.paging import ItemPaged
from azure.core.pipeline import PipelineResponse
-from azure.core.pipeline.transport import HttpResponse
-from azure.core.rest import HttpRequest
+from azure.core.rest import HttpRequest, HttpResponse
from azure.core.tracing.decorator import distributed_trace
from azure.core.utils import case_insensitive_dict
from azure.mgmt.core.exceptions import ARMErrorFormat
from .. import models as _models
from .._serialization import Serializer
-from .._vendor import _convert_request, _format_url_section
-if sys.version_info >= (3, 8):
- from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports
+if sys.version_info >= (3, 9):
+ from collections.abc import MutableMapping
else:
- from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports
+ from typing import MutableMapping # type: ignore
T = TypeVar("T")
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]]
@@ -44,9 +42,7 @@ def build_list_by_subscription_request(subscription_id: str, **kwargs: Any) -> H
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -57,7 +53,7 @@ def build_list_by_subscription_request(subscription_id: str, **kwargs: Any) -> H
"subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str", min_length=1),
}
- _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore
+ _url: str = _url.format(**path_format_arguments) # type: ignore
# Construct parameters
_params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -72,9 +68,7 @@ def build_list_by_resource_group_request(resource_group_name: str, subscription_
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -89,7 +83,7 @@ def build_list_by_resource_group_request(resource_group_name: str, subscription_
),
}
- _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore
+ _url: str = _url.format(**path_format_arguments) # type: ignore
# Construct parameters
_params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -106,9 +100,7 @@ def build_get_request(
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -121,10 +113,10 @@ def build_get_request(
"resourceGroupName": _SERIALIZER.url(
"resource_group_name", resource_group_name, "str", max_length=90, min_length=1
),
- "ruleGroupName": _SERIALIZER.url("rule_group_name", rule_group_name, "str"),
+ "ruleGroupName": _SERIALIZER.url("rule_group_name", rule_group_name, "str", pattern=r"^[^:@/#{}%&+*<>?]+$"),
}
- _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore
+ _url: str = _url.format(**path_format_arguments) # type: ignore
# Construct parameters
_params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -141,9 +133,7 @@ def build_create_or_update_request(
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
accept = _headers.pop("Accept", "application/json")
@@ -157,10 +147,10 @@ def build_create_or_update_request(
"resourceGroupName": _SERIALIZER.url(
"resource_group_name", resource_group_name, "str", max_length=90, min_length=1
),
- "ruleGroupName": _SERIALIZER.url("rule_group_name", rule_group_name, "str"),
+ "ruleGroupName": _SERIALIZER.url("rule_group_name", rule_group_name, "str", pattern=r"^[^:@/#{}%&+*<>?]+$"),
}
- _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore
+ _url: str = _url.format(**path_format_arguments) # type: ignore
# Construct parameters
_params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -179,9 +169,7 @@ def build_update_request(
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
accept = _headers.pop("Accept", "application/json")
@@ -195,10 +183,10 @@ def build_update_request(
"resourceGroupName": _SERIALIZER.url(
"resource_group_name", resource_group_name, "str", max_length=90, min_length=1
),
- "ruleGroupName": _SERIALIZER.url("rule_group_name", rule_group_name, "str"),
+ "ruleGroupName": _SERIALIZER.url("rule_group_name", rule_group_name, "str", pattern=r"^[^:@/#{}%&+*<>?]+$"),
}
- _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore
+ _url: str = _url.format(**path_format_arguments) # type: ignore
# Construct parameters
_params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -217,9 +205,7 @@ def build_delete_request(
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -232,10 +218,10 @@ def build_delete_request(
"resourceGroupName": _SERIALIZER.url(
"resource_group_name", resource_group_name, "str", max_length=90, min_length=1
),
- "ruleGroupName": _SERIALIZER.url("rule_group_name", rule_group_name, "str"),
+ "ruleGroupName": _SERIALIZER.url("rule_group_name", rule_group_name, "str", pattern=r"^[^:@/#{}%&+*<>?]+$"),
}
- _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore
+ _url: str = _url.format(**path_format_arguments) # type: ignore
# Construct parameters
_params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -267,9 +253,8 @@ def __init__(self, *args, **kwargs):
@distributed_trace
def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.PrometheusRuleGroupResource"]:
- """Retrieve Prometheus rule group definitions in a subscription.
+ """Retrieve Prometheus all rule group definitions in a subscription.
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either PrometheusRuleGroupResource or the result of
cls(response)
:rtype:
@@ -279,12 +264,10 @@ def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.PrometheusRul
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
cls: ClsType[_models.PrometheusRuleGroupResourceCollection] = kwargs.pop("cls", None)
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -295,22 +278,19 @@ def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.PrometheusRul
def prepare_request(next_link=None):
if not next_link:
- request = build_list_by_subscription_request(
+ _request = build_list_by_subscription_request(
subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.list_by_subscription.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
else:
- request = HttpRequest("GET", next_link)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
- request.method = "GET"
- return request
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
def extract_data(pipeline_response):
deserialized = self._deserialize("PrometheusRuleGroupResourceCollection", pipeline_response)
@@ -320,26 +300,23 @@ def extract_data(pipeline_response):
return None, iter(list_of_elem)
def get_next(next_link=None):
- request = prepare_request(next_link)
+ _request = prepare_request(next_link)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated, pipeline_response)
+ 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)
- list_by_subscription.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/prometheusRuleGroups"
- }
-
@distributed_trace
def list_by_resource_group(
self, resource_group_name: str, **kwargs: Any
@@ -349,7 +326,6 @@ def list_by_resource_group(
:param resource_group_name: The name of the resource group. The name is case insensitive.
Required.
:type resource_group_name: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either PrometheusRuleGroupResource or the result of
cls(response)
:rtype:
@@ -359,12 +335,10 @@ def list_by_resource_group(
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
cls: ClsType[_models.PrometheusRuleGroupResourceCollection] = kwargs.pop("cls", None)
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -375,23 +349,20 @@ def list_by_resource_group(
def prepare_request(next_link=None):
if not next_link:
- request = build_list_by_resource_group_request(
+ _request = build_list_by_resource_group_request(
resource_group_name=resource_group_name,
subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.list_by_resource_group.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
else:
- request = HttpRequest("GET", next_link)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
- request.method = "GET"
- return request
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
def extract_data(pipeline_response):
deserialized = self._deserialize("PrometheusRuleGroupResourceCollection", pipeline_response)
@@ -401,26 +372,23 @@ def extract_data(pipeline_response):
return None, iter(list_of_elem)
def get_next(next_link=None):
- request = prepare_request(next_link)
+ _request = prepare_request(next_link)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated, pipeline_response)
+ 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)
- list_by_resource_group.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/prometheusRuleGroups"
- }
-
@distributed_trace
def get(self, resource_group_name: str, rule_group_name: str, **kwargs: Any) -> _models.PrometheusRuleGroupResource:
"""Retrieve a Prometheus rule group definition.
@@ -430,12 +398,11 @@ def get(self, resource_group_name: str, rule_group_name: str, **kwargs: Any) ->
:type resource_group_name: str
:param rule_group_name: The name of the rule group. Required.
:type rule_group_name: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: PrometheusRuleGroupResource or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -446,44 +413,37 @@ def get(self, resource_group_name: str, rule_group_name: str, **kwargs: Any) ->
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
cls: ClsType[_models.PrometheusRuleGroupResource] = kwargs.pop("cls", None)
- request = build_get_request(
+ _request = build_get_request(
resource_group_name=resource_group_name,
rule_group_name=rule_group_name,
subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.get.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("PrometheusRuleGroupResource", pipeline_response)
+ deserialized = self._deserialize("PrometheusRuleGroupResource", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
-
- return deserialized
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- get.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/prometheusRuleGroups/{ruleGroupName}"
- }
+ return deserialized # type: ignore
@overload
def create_or_update(
@@ -507,7 +467,6 @@ def create_or_update(
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: PrometheusRuleGroupResource or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource
:raises ~azure.core.exceptions.HttpResponseError:
@@ -518,7 +477,7 @@ def create_or_update(
self,
resource_group_name: str,
rule_group_name: str,
- parameters: IO,
+ parameters: IO[bytes],
*,
content_type: str = "application/json",
**kwargs: Any
@@ -531,11 +490,10 @@ def create_or_update(
:param rule_group_name: The name of the rule group. Required.
:type rule_group_name: str
:param parameters: The parameters of the rule group to create or update. Required.
- :type parameters: IO
+ :type parameters: IO[bytes]
:keyword content_type: Body Parameter content-type. Content type parameter for binary body.
Default value is "application/json".
:paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: PrometheusRuleGroupResource or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource
:raises ~azure.core.exceptions.HttpResponseError:
@@ -546,7 +504,7 @@ def create_or_update(
self,
resource_group_name: str,
rule_group_name: str,
- parameters: Union[_models.PrometheusRuleGroupResource, IO],
+ parameters: Union[_models.PrometheusRuleGroupResource, IO[bytes]],
**kwargs: Any
) -> _models.PrometheusRuleGroupResource:
"""Create or update a Prometheus rule group definition.
@@ -556,18 +514,14 @@ def create_or_update(
:type resource_group_name: str
:param rule_group_name: The name of the rule group. Required.
:type rule_group_name: str
- :param parameters: The parameters of the rule group to create or update. Is either a model type
- or a IO type. Required.
- :type parameters: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource or IO
- :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
- Default value is None.
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
+ :param parameters: The parameters of the rule group to create or update. Is either a
+ PrometheusRuleGroupResource type or a IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource or IO[bytes]
:return: PrometheusRuleGroupResource or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -578,21 +532,19 @@ def create_or_update(
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
cls: ClsType[_models.PrometheusRuleGroupResource] = kwargs.pop("cls", None)
content_type = content_type or "application/json"
_json = None
_content = None
- if isinstance(parameters, (IO, bytes)):
+ if isinstance(parameters, (IOBase, bytes)):
_content = parameters
else:
_json = self._serialize.body(parameters, "PrometheusRuleGroupResource")
- request = build_create_or_update_request(
+ _request = build_create_or_update_request(
resource_group_name=resource_group_name,
rule_group_name=rule_group_name,
subscription_id=self._config.subscription_id,
@@ -600,45 +552,36 @@ def create_or_update(
content_type=content_type,
json=_json,
content=_content,
- template_url=self.create_or_update.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _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.ErrorResponseAutoGenerated, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- if response.status_code == 200:
- deserialized = self._deserialize("PrometheusRuleGroupResource", pipeline_response)
-
- if response.status_code == 201:
- deserialized = self._deserialize("PrometheusRuleGroupResource", pipeline_response)
+ deserialized = self._deserialize("PrometheusRuleGroupResource", pipeline_response.http_response)
if cls:
return cls(pipeline_response, deserialized, {}) # type: ignore
return deserialized # type: ignore
- create_or_update.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/prometheusRuleGroups/{ruleGroupName}"
- }
-
@overload
def update(
self,
resource_group_name: str,
rule_group_name: str,
- parameters: _models.PrometheusRuleGroupResourcePatch,
+ parameters: _models.PrometheusRuleGroupResourcePatchParameters,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -651,11 +594,11 @@ def update(
:param rule_group_name: The name of the rule group. Required.
:type rule_group_name: str
:param parameters: The parameters of the rule group to update. Required.
- :type parameters: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResourcePatch
+ :type parameters:
+ ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResourcePatchParameters
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: PrometheusRuleGroupResource or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource
:raises ~azure.core.exceptions.HttpResponseError:
@@ -666,7 +609,7 @@ def update(
self,
resource_group_name: str,
rule_group_name: str,
- parameters: IO,
+ parameters: IO[bytes],
*,
content_type: str = "application/json",
**kwargs: Any
@@ -679,11 +622,10 @@ def update(
:param rule_group_name: The name of the rule group. Required.
:type rule_group_name: str
:param parameters: The parameters of the rule group to update. Required.
- :type parameters: IO
+ :type parameters: IO[bytes]
:keyword content_type: Body Parameter content-type. Content type parameter for binary body.
Default value is "application/json".
:paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: PrometheusRuleGroupResource or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource
:raises ~azure.core.exceptions.HttpResponseError:
@@ -694,7 +636,7 @@ def update(
self,
resource_group_name: str,
rule_group_name: str,
- parameters: Union[_models.PrometheusRuleGroupResourcePatch, IO],
+ parameters: Union[_models.PrometheusRuleGroupResourcePatchParameters, IO[bytes]],
**kwargs: Any
) -> _models.PrometheusRuleGroupResource:
"""Update an Prometheus rule group definition.
@@ -704,18 +646,15 @@ def update(
:type resource_group_name: str
:param rule_group_name: The name of the rule group. Required.
:type rule_group_name: str
- :param parameters: The parameters of the rule group to update. Is either a model type or a IO
- type. Required.
- :type parameters: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResourcePatch or IO
- :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
- Default value is None.
- :paramtype content_type: str
- :keyword callable cls: A custom type or function that will be passed the direct response
+ :param parameters: The parameters of the rule group to update. Is either a
+ PrometheusRuleGroupResourcePatchParameters type or a IO[bytes] type. Required.
+ :type parameters:
+ ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResourcePatchParameters or IO[bytes]
:return: PrometheusRuleGroupResource or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.PrometheusRuleGroupResource
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -726,21 +665,19 @@ def update(
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
cls: ClsType[_models.PrometheusRuleGroupResource] = kwargs.pop("cls", None)
content_type = content_type or "application/json"
_json = None
_content = None
- if isinstance(parameters, (IO, bytes)):
+ if isinstance(parameters, (IOBase, bytes)):
_content = parameters
else:
- _json = self._serialize.body(parameters, "PrometheusRuleGroupResourcePatch")
+ _json = self._serialize.body(parameters, "PrometheusRuleGroupResourcePatchParameters")
- request = build_update_request(
+ _request = build_update_request(
resource_group_name=resource_group_name,
rule_group_name=rule_group_name,
subscription_id=self._config.subscription_id,
@@ -748,34 +685,29 @@ def update(
content_type=content_type,
json=_json,
content=_content,
- template_url=self.update.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = 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.ErrorResponseAutoGenerated, pipeline_response)
+ error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("PrometheusRuleGroupResource", pipeline_response)
+ deserialized = self._deserialize("PrometheusRuleGroupResource", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
-
- return deserialized
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- update.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/prometheusRuleGroups/{ruleGroupName}"
- }
+ return deserialized # type: ignore
@distributed_trace
def delete( # pylint: disable=inconsistent-return-statements
@@ -788,12 +720,11 @@ def delete( # pylint: disable=inconsistent-return-statements
:type resource_group_name: str
:param rule_group_name: The name of the rule group. Required.
:type rule_group_name: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: None or the result of cls(response)
:rtype: None
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -804,37 +735,30 @@ def delete( # pylint: disable=inconsistent-return-statements
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2021-07-22-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2021-07-22-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-03-01"))
cls: ClsType[None] = kwargs.pop("cls", None)
- request = build_delete_request(
+ _request = build_delete_request(
resource_group_name=resource_group_name,
rule_group_name=rule_group_name,
subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.delete.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _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.ErrorResponseAutoGenerated, pipeline_response)
+ 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, {})
-
- delete.metadata = {
- "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AlertsManagement/prometheusRuleGroups/{ruleGroupName}"
- }
+ return cls(pipeline_response, None, {}) # type: ignore
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_smart_groups_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_smart_groups_operations.py
index cdb08c4cc687c..382ea9ca1c077 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_smart_groups_operations.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/azure/mgmt/alertsmanagement/operations/_smart_groups_operations.py
@@ -1,4 +1,3 @@
-# pylint: disable=too-many-lines
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
@@ -19,20 +18,18 @@
)
from azure.core.paging import ItemPaged
from azure.core.pipeline import PipelineResponse
-from azure.core.pipeline.transport import HttpResponse
-from azure.core.rest import HttpRequest
+from azure.core.rest import HttpRequest, HttpResponse
from azure.core.tracing.decorator import distributed_trace
from azure.core.utils import case_insensitive_dict
from azure.mgmt.core.exceptions import ARMErrorFormat
from .. import models as _models
from .._serialization import Serializer
-from .._vendor import _convert_request, _format_url_section
-if sys.version_info >= (3, 8):
- from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports
+if sys.version_info >= (3, 9):
+ from collections.abc import MutableMapping
else:
- from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports
+ from typing import MutableMapping # type: ignore
T = TypeVar("T")
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]]
@@ -59,9 +56,7 @@ def build_get_all_request(
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-05-05-preview"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -72,7 +67,7 @@ def build_get_all_request(
"subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str", min_length=1),
}
- _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore
+ _url: str = _url.format(**path_format_arguments) # type: ignore
# Construct parameters
if target_resource is not None:
@@ -109,9 +104,7 @@ def build_get_by_id_request(smart_group_id: str, subscription_id: str, **kwargs:
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-05-05-preview"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -124,7 +117,7 @@ def build_get_by_id_request(smart_group_id: str, subscription_id: str, **kwargs:
"smartGroupId": _SERIALIZER.url("smart_group_id", smart_group_id, "str"),
}
- _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore
+ _url: str = _url.format(**path_format_arguments) # type: ignore
# Construct parameters
_params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -141,9 +134,7 @@ def build_change_state_request(
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-05-05-preview"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -156,7 +147,7 @@ def build_change_state_request(
"smartGroupId": _SERIALIZER.url("smart_group_id", smart_group_id, "str"),
}
- _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore
+ _url: str = _url.format(**path_format_arguments) # type: ignore
# Construct parameters
_params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -172,9 +163,7 @@ def build_get_history_request(smart_group_id: str, subscription_id: str, **kwarg
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-05-05-preview"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -187,7 +176,7 @@ def build_get_history_request(smart_group_id: str, subscription_id: str, **kwarg
"smartGroupId": _SERIALIZER.url("smart_group_id", smart_group_id, "str"),
}
- _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore
+ _url: str = _url.format(**path_format_arguments) # type: ignore
# Construct parameters
_params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -250,7 +239,7 @@ def get_all(
value is select all. Known values are: "Application Insights", "ActivityLog Administrative",
"ActivityLog Security", "ActivityLog Recommendation", "ActivityLog Policy", "ActivityLog
Autoscale", "Log Analytics", "Nagios", "Platform", "SCOM", "ServiceHealth", "SmartDetector",
- "VM Insights", and "Zabbix". Default value is None.
+ "VM Insights", "Zabbix", and "Resource Health". Default value is None.
:type monitor_service: str or ~azure.mgmt.alertsmanagement.models.MonitorService
:param monitor_condition: Filter by monitor condition which is either 'Fired' or 'Resolved'.
Default value is to select all. Known values are: "Fired" and "Resolved". Default value is
@@ -277,7 +266,6 @@ def get_all(
value is 'desc' for time fields and 'asc' for others. Known values are: "asc" and "desc".
Default value is None.
:type sort_order: str or ~azure.mgmt.alertsmanagement.models.SortOrder
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either SmartGroup or the result of cls(response)
:rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.alertsmanagement.models.SmartGroup]
:raises ~azure.core.exceptions.HttpResponseError:
@@ -285,12 +273,10 @@ def get_all(
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-05-05-preview"))
cls: ClsType[_models.SmartGroupsList] = kwargs.pop("cls", None)
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -301,7 +287,7 @@ def get_all(
def prepare_request(next_link=None):
if not next_link:
- request = build_get_all_request(
+ _request = build_get_all_request(
subscription_id=self._config.subscription_id,
target_resource=target_resource,
target_resource_group=target_resource_group,
@@ -315,19 +301,16 @@ def prepare_request(next_link=None):
sort_by=sort_by,
sort_order=sort_order,
api_version=api_version,
- template_url=self.get_all.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
else:
- request = HttpRequest("GET", next_link)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
- request.method = "GET"
- return request
+ _request = HttpRequest("GET", next_link)
+ _request.url = self._client.format_url(_request.url)
+ _request.method = "GET"
+ return _request
def extract_data(pipeline_response):
deserialized = self._deserialize("SmartGroupsList", pipeline_response)
@@ -337,10 +320,11 @@ def extract_data(pipeline_response):
return deserialized.next_link or None, iter(list_of_elem)
def get_next(next_link=None):
- request = prepare_request(next_link)
+ _request = prepare_request(next_link)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = pipeline_response.http_response
@@ -353,8 +337,6 @@ def get_next(next_link=None):
return ItemPaged(get_next, extract_data)
- get_all.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/smartGroups"}
-
@distributed_trace
def get_by_id(self, smart_group_id: str, **kwargs: Any) -> _models.SmartGroup:
"""Get information related to a specific Smart Group.
@@ -363,12 +345,11 @@ def get_by_id(self, smart_group_id: str, **kwargs: Any) -> _models.SmartGroup:
:param smart_group_id: Smart group unique id. Required.
:type smart_group_id: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: SmartGroup or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.SmartGroup
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -379,24 +360,21 @@ def get_by_id(self, smart_group_id: str, **kwargs: Any) -> _models.SmartGroup:
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-05-05-preview"))
cls: ClsType[_models.SmartGroup] = kwargs.pop("cls", None)
- request = build_get_by_id_request(
+ _request = build_get_by_id_request(
smart_group_id=smart_group_id,
subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.get_by_id.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = pipeline_response.http_response
@@ -409,16 +387,12 @@ def get_by_id(self, smart_group_id: str, **kwargs: Any) -> _models.SmartGroup:
response_headers = {}
response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
- deserialized = self._deserialize("SmartGroup", pipeline_response)
+ deserialized = self._deserialize("SmartGroup", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, response_headers)
+ return cls(pipeline_response, deserialized, response_headers) # type: ignore
- return deserialized
-
- get_by_id.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/smartGroups/{smartGroupId}"
- }
+ return deserialized # type: ignore
@distributed_trace
def change_state(
@@ -431,12 +405,11 @@ def change_state(
:param new_state: New state of the alert. Known values are: "New", "Acknowledged", and
"Closed". Required.
:type new_state: str or ~azure.mgmt.alertsmanagement.models.AlertState
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: SmartGroup or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.SmartGroup
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -447,25 +420,22 @@ def change_state(
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-05-05-preview"))
cls: ClsType[_models.SmartGroup] = kwargs.pop("cls", None)
- request = build_change_state_request(
+ _request = build_change_state_request(
smart_group_id=smart_group_id,
subscription_id=self._config.subscription_id,
new_state=new_state,
api_version=api_version,
- template_url=self.change_state.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = pipeline_response.http_response
@@ -478,16 +448,12 @@ def change_state(
response_headers = {}
response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id"))
- deserialized = self._deserialize("SmartGroup", pipeline_response)
+ deserialized = self._deserialize("SmartGroup", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, response_headers)
+ return cls(pipeline_response, deserialized, response_headers) # type: ignore
- return deserialized
-
- change_state.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/smartGroups/{smartGroupId}/changeState"
- }
+ return deserialized # type: ignore
@distributed_trace
def get_history(self, smart_group_id: str, **kwargs: Any) -> _models.SmartGroupModification:
@@ -496,12 +462,11 @@ def get_history(self, smart_group_id: str, **kwargs: Any) -> _models.SmartGroupM
:param smart_group_id: Smart group unique id. Required.
:type smart_group_id: str
- :keyword callable cls: A custom type or function that will be passed the direct response
:return: SmartGroupModification or the result of cls(response)
:rtype: ~azure.mgmt.alertsmanagement.models.SmartGroupModification
:raises ~azure.core.exceptions.HttpResponseError:
"""
- error_map = {
+ error_map: MutableMapping = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError,
@@ -512,24 +477,21 @@ def get_history(self, smart_group_id: str, **kwargs: Any) -> _models.SmartGroupM
_headers = kwargs.pop("headers", {}) or {}
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: Literal["2019-05-05-preview"] = kwargs.pop(
- "api_version", _params.pop("api-version", "2019-05-05-preview")
- )
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2019-05-05-preview"))
cls: ClsType[_models.SmartGroupModification] = kwargs.pop("cls", None)
- request = build_get_history_request(
+ _request = build_get_history_request(
smart_group_id=smart_group_id,
subscription_id=self._config.subscription_id,
api_version=api_version,
- template_url=self.get_history.metadata["url"],
headers=_headers,
params=_params,
)
- request = _convert_request(request)
- request.url = self._client.format_url(request.url)
+ _request.url = self._client.format_url(_request.url)
+ _stream = False
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
- request, stream=False, **kwargs
+ _request, stream=_stream, **kwargs
)
response = pipeline_response.http_response
@@ -539,13 +501,9 @@ def get_history(self, smart_group_id: str, **kwargs: Any) -> _models.SmartGroupM
error = self._deserialize.failsafe_deserialize(_models.ErrorResponseAutoGenerated3, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
- deserialized = self._deserialize("SmartGroupModification", pipeline_response)
+ deserialized = self._deserialize("SmartGroupModification", pipeline_response.http_response)
if cls:
- return cls(pipeline_response, deserialized, {})
-
- return deserialized
+ return cls(pipeline_response, deserialized, {}) # type: ignore
- get_history.metadata = {
- "url": "/subscriptions/{subscriptionId}/providers/Microsoft.AlertsManagement/smartGroups/{smartGroupId}/history"
- }
+ return deserialized # type: ignore
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_add_action_group_all_alerts_in_subscription.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_add_action_group_all_alerts_in_subscription.py
deleted file mode 100644
index 16c15fa80e428..0000000000000
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_add_action_group_all_alerts_in_subscription.py
+++ /dev/null
@@ -1,58 +0,0 @@
-# coding=utf-8
-# --------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for license information.
-# Code generated by Microsoft (R) AutoRest Code Generator.
-# Changes may cause incorrect behavior and will be lost if the code is regenerated.
-# --------------------------------------------------------------------------
-
-from azure.identity import DefaultAzureCredential
-from azure.mgmt.alertsmanagement import AlertsManagementClient
-
-"""
-# PREREQUISITES
- pip install azure-identity
- pip install azure-mgmt-alertsmanagement
-# USAGE
- python alert_processing_rules_create_or_update_add_action_group_all_alerts_in_subscription.py
-
- Before run the sample, please set the values of the client ID, tenant ID and client secret
- of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
- AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
- https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
-"""
-
-
-def main():
- client = AlertsManagementClient(
- credential=DefaultAzureCredential(),
- subscription_id="subId1",
- )
-
- response = client.alert_processing_rules.create_or_update(
- resource_group_name="alertscorrelationrg",
- alert_processing_rule_name="AddActionGroupToSubscription",
- alert_processing_rule={
- "location": "Global",
- "properties": {
- "actions": [
- {
- "actionGroupIds": [
- "/subscriptions/subId1/resourcegroups/RGId1/providers/microsoft.insights/actiongroups/ActionGroup1"
- ],
- "actionType": "AddActionGroups",
- }
- ],
- "description": "Add ActionGroup1 to all alerts in the subscription",
- "enabled": True,
- "scopes": ["/subscriptions/subId1"],
- },
- "tags": {},
- },
- )
- print(response)
-
-
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2021-08-08/examples/AlertProcessingRules_Create_or_update_add_action_group_all_alerts_in_subscription.json
-if __name__ == "__main__":
- main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_add_two_action_groups_all_sev0_sev1_two_resource_groups.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_add_two_action_groups_all_sev0_sev1_two_resource_groups.py
deleted file mode 100644
index 301a8f60c27cc..0000000000000
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_add_two_action_groups_all_sev0_sev1_two_resource_groups.py
+++ /dev/null
@@ -1,60 +0,0 @@
-# coding=utf-8
-# --------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for license information.
-# Code generated by Microsoft (R) AutoRest Code Generator.
-# Changes may cause incorrect behavior and will be lost if the code is regenerated.
-# --------------------------------------------------------------------------
-
-from azure.identity import DefaultAzureCredential
-from azure.mgmt.alertsmanagement import AlertsManagementClient
-
-"""
-# PREREQUISITES
- pip install azure-identity
- pip install azure-mgmt-alertsmanagement
-# USAGE
- python alert_processing_rules_create_or_update_add_two_action_groups_all_sev0_sev1_two_resource_groups.py
-
- Before run the sample, please set the values of the client ID, tenant ID and client secret
- of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
- AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
- https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
-"""
-
-
-def main():
- client = AlertsManagementClient(
- credential=DefaultAzureCredential(),
- subscription_id="subId1",
- )
-
- response = client.alert_processing_rules.create_or_update(
- resource_group_name="alertscorrelationrg",
- alert_processing_rule_name="AddActionGroupsBySeverity",
- alert_processing_rule={
- "location": "Global",
- "properties": {
- "actions": [
- {
- "actionGroupIds": [
- "/subscriptions/subId1/resourcegroups/RGId1/providers/microsoft.insights/actiongroups/AGId1",
- "/subscriptions/subId1/resourcegroups/RGId1/providers/microsoft.insights/actiongroups/AGId2",
- ],
- "actionType": "AddActionGroups",
- }
- ],
- "conditions": [{"field": "Severity", "operator": "Equals", "values": ["sev0", "sev1"]}],
- "description": "Add AGId1 and AGId2 to all Sev0 and Sev1 alerts in these resourceGroups",
- "enabled": True,
- "scopes": ["/subscriptions/subId1/resourceGroups/RGId1", "/subscriptions/subId1/resourceGroups/RGId2"],
- },
- "tags": {},
- },
- )
- print(response)
-
-
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2021-08-08/examples/AlertProcessingRules_Create_or_update_add_two_action_groups_all_Sev0_Sev1_two_resource_groups.json
-if __name__ == "__main__":
- main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_remove_all_action_groups_from_specific_alert_rule.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_remove_all_action_groups_from_specific_alert_rule.py
deleted file mode 100644
index 96a81089ab2db..0000000000000
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_remove_all_action_groups_from_specific_alert_rule.py
+++ /dev/null
@@ -1,60 +0,0 @@
-# coding=utf-8
-# --------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for license information.
-# Code generated by Microsoft (R) AutoRest Code Generator.
-# Changes may cause incorrect behavior and will be lost if the code is regenerated.
-# --------------------------------------------------------------------------
-
-from azure.identity import DefaultAzureCredential
-from azure.mgmt.alertsmanagement import AlertsManagementClient
-
-"""
-# PREREQUISITES
- pip install azure-identity
- pip install azure-mgmt-alertsmanagement
-# USAGE
- python alert_processing_rules_create_or_update_remove_all_action_groups_from_specific_alert_rule.py
-
- Before run the sample, please set the values of the client ID, tenant ID and client secret
- of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
- AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
- https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
-"""
-
-
-def main():
- client = AlertsManagementClient(
- credential=DefaultAzureCredential(),
- subscription_id="subId1",
- )
-
- response = client.alert_processing_rules.create_or_update(
- resource_group_name="alertscorrelationrg",
- alert_processing_rule_name="RemoveActionGroupsSpecificAlertRule",
- alert_processing_rule={
- "location": "Global",
- "properties": {
- "actions": [{"actionType": "RemoveAllActionGroups"}],
- "conditions": [
- {
- "field": "AlertRuleId",
- "operator": "Equals",
- "values": [
- "/subscriptions/suubId1/resourceGroups/Rgid2/providers/microsoft.insights/activityLogAlerts/RuleName"
- ],
- }
- ],
- "description": "Removes all ActionGroups from all Alerts that fire on above AlertRule",
- "enabled": True,
- "scopes": ["/subscriptions/subId1"],
- },
- "tags": {},
- },
- )
- print(response)
-
-
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2021-08-08/examples/AlertProcessingRules_Create_or_update_remove_all_action_groups_from_specific_alert_rule.json
-if __name__ == "__main__":
- main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_remove_all_action_groups_outside_business_hours.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_remove_all_action_groups_outside_business_hours.py
deleted file mode 100644
index 732b8a5157a92..0000000000000
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_remove_all_action_groups_outside_business_hours.py
+++ /dev/null
@@ -1,58 +0,0 @@
-# coding=utf-8
-# --------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for license information.
-# Code generated by Microsoft (R) AutoRest Code Generator.
-# Changes may cause incorrect behavior and will be lost if the code is regenerated.
-# --------------------------------------------------------------------------
-
-from azure.identity import DefaultAzureCredential
-from azure.mgmt.alertsmanagement import AlertsManagementClient
-
-"""
-# PREREQUISITES
- pip install azure-identity
- pip install azure-mgmt-alertsmanagement
-# USAGE
- python alert_processing_rules_create_or_update_remove_all_action_groups_outside_business_hours.py
-
- Before run the sample, please set the values of the client ID, tenant ID and client secret
- of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
- AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
- https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
-"""
-
-
-def main():
- client = AlertsManagementClient(
- credential=DefaultAzureCredential(),
- subscription_id="subId1",
- )
-
- response = client.alert_processing_rules.create_or_update(
- resource_group_name="alertscorrelationrg",
- alert_processing_rule_name="RemoveActionGroupsOutsideBusinessHours",
- alert_processing_rule={
- "location": "Global",
- "properties": {
- "actions": [{"actionType": "RemoveAllActionGroups"}],
- "description": "Remove all ActionGroups outside business hours",
- "enabled": True,
- "schedule": {
- "recurrences": [
- {"endTime": "09:00:00", "recurrenceType": "Daily", "startTime": "17:00:00"},
- {"daysOfWeek": ["Saturday", "Sunday"], "recurrenceType": "Weekly"},
- ],
- "timeZone": "Eastern Standard Time",
- },
- "scopes": ["/subscriptions/subId1"],
- },
- "tags": {},
- },
- )
- print(response)
-
-
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2021-08-08/examples/AlertProcessingRules_Create_or_update_remove_all_action_groups_outside_business_hours.json
-if __name__ == "__main__":
- main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_remove_all_action_groups_recurring_maintenance_window.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_remove_all_action_groups_recurring_maintenance_window.py
deleted file mode 100644
index 2b2df653a6b81..0000000000000
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_remove_all_action_groups_recurring_maintenance_window.py
+++ /dev/null
@@ -1,69 +0,0 @@
-# coding=utf-8
-# --------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for license information.
-# Code generated by Microsoft (R) AutoRest Code Generator.
-# Changes may cause incorrect behavior and will be lost if the code is regenerated.
-# --------------------------------------------------------------------------
-
-from azure.identity import DefaultAzureCredential
-from azure.mgmt.alertsmanagement import AlertsManagementClient
-
-"""
-# PREREQUISITES
- pip install azure-identity
- pip install azure-mgmt-alertsmanagement
-# USAGE
- python alert_processing_rules_create_or_update_remove_all_action_groups_recurring_maintenance_window.py
-
- Before run the sample, please set the values of the client ID, tenant ID and client secret
- of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
- AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
- https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
-"""
-
-
-def main():
- client = AlertsManagementClient(
- credential=DefaultAzureCredential(),
- subscription_id="subId1",
- )
-
- response = client.alert_processing_rules.create_or_update(
- resource_group_name="alertscorrelationrg",
- alert_processing_rule_name="RemoveActionGroupsRecurringMaintenance",
- alert_processing_rule={
- "location": "Global",
- "properties": {
- "actions": [{"actionType": "RemoveAllActionGroups"}],
- "conditions": [
- {
- "field": "TargetResourceType",
- "operator": "Equals",
- "values": ["microsoft.compute/virtualmachines"],
- }
- ],
- "description": "Remove all ActionGroups from all Vitual machine Alerts during the recurring maintenance",
- "enabled": True,
- "schedule": {
- "recurrences": [
- {
- "daysOfWeek": ["Saturday", "Sunday"],
- "endTime": "04:00:00",
- "recurrenceType": "Weekly",
- "startTime": "22:00:00",
- }
- ],
- "timeZone": "India Standard Time",
- },
- "scopes": ["/subscriptions/subId1/resourceGroups/RGId1", "/subscriptions/subId1/resourceGroups/RGId2"],
- },
- "tags": {},
- },
- )
- print(response)
-
-
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2021-08-08/examples/AlertProcessingRules_Create_or_update_remove_all_action_groups_recurring_maintenance_window.json
-if __name__ == "__main__":
- main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_remove_all_action_groups_specific_vm_oneoff_maintenance_window.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_remove_all_action_groups_specific_vm_oneoff_maintenance_window.py
deleted file mode 100644
index 727053369ddff..0000000000000
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_create_or_update_remove_all_action_groups_specific_vm_oneoff_maintenance_window.py
+++ /dev/null
@@ -1,58 +0,0 @@
-# coding=utf-8
-# --------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for license information.
-# Code generated by Microsoft (R) AutoRest Code Generator.
-# Changes may cause incorrect behavior and will be lost if the code is regenerated.
-# --------------------------------------------------------------------------
-
-from azure.identity import DefaultAzureCredential
-from azure.mgmt.alertsmanagement import AlertsManagementClient
-
-"""
-# PREREQUISITES
- pip install azure-identity
- pip install azure-mgmt-alertsmanagement
-# USAGE
- python alert_processing_rules_create_or_update_remove_all_action_groups_specific_vm_oneoff_maintenance_window.py
-
- Before run the sample, please set the values of the client ID, tenant ID and client secret
- of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
- AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
- https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
-"""
-
-
-def main():
- client = AlertsManagementClient(
- credential=DefaultAzureCredential(),
- subscription_id="subId1",
- )
-
- response = client.alert_processing_rules.create_or_update(
- resource_group_name="alertscorrelationrg",
- alert_processing_rule_name="RemoveActionGroupsMaintenanceWindow",
- alert_processing_rule={
- "location": "Global",
- "properties": {
- "actions": [{"actionType": "RemoveAllActionGroups"}],
- "description": "Removes all ActionGroups from all Alerts on VMName during the maintenance window",
- "enabled": True,
- "schedule": {
- "effectiveFrom": "2021-04-15T18:00:00",
- "effectiveUntil": "2021-04-15T20:00:00",
- "timeZone": "Pacific Standard Time",
- },
- "scopes": [
- "/subscriptions/subId1/resourceGroups/RGId1/providers/Microsoft.Compute/virtualMachines/VMName"
- ],
- },
- "tags": {},
- },
- )
- print(response)
-
-
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2021-08-08/examples/AlertProcessingRules_Create_or_update_remove_all_action_groups_specific_VM_one-off_maintenance_window.json
-if __name__ == "__main__":
- main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_patch.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_patch.py
deleted file mode 100644
index 8e49a347b9b00..0000000000000
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_patch.py
+++ /dev/null
@@ -1,42 +0,0 @@
-# coding=utf-8
-# --------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for license information.
-# Code generated by Microsoft (R) AutoRest Code Generator.
-# Changes may cause incorrect behavior and will be lost if the code is regenerated.
-# --------------------------------------------------------------------------
-
-from azure.identity import DefaultAzureCredential
-from azure.mgmt.alertsmanagement import AlertsManagementClient
-
-"""
-# PREREQUISITES
- pip install azure-identity
- pip install azure-mgmt-alertsmanagement
-# USAGE
- python alert_processing_rules_patch.py
-
- Before run the sample, please set the values of the client ID, tenant ID and client secret
- of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
- AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
- https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
-"""
-
-
-def main():
- client = AlertsManagementClient(
- credential=DefaultAzureCredential(),
- subscription_id="1e3ff1c0-771a-4119-a03b-be82a51e232d",
- )
-
- response = client.alert_processing_rules.update(
- resource_group_name="alertscorrelationrg",
- alert_processing_rule_name="WeeklySuppression",
- alert_processing_rule_patch={"properties": {"enabled": False}, "tags": {"key1": "value1", "key2": "value2"}},
- )
- print(response)
-
-
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2021-08-08/examples/AlertProcessingRules_Patch.json
-if __name__ == "__main__":
- main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_rule_recommendations_get_by_resource_mac.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_rule_recommendations_get_by_resource_mac.py
new file mode 100644
index 0000000000000..9055a24826f92
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_rule_recommendations_get_by_resource_mac.py
@@ -0,0 +1,42 @@
+# 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 azure.identity import DefaultAzureCredential
+
+from azure.mgmt.alertsmanagement import AlertsManagementClient
+
+"""
+# PREREQUISITES
+ pip install azure-identity
+ pip install azure-mgmt-alertsmanagement
+# USAGE
+ python alert_rule_recommendations_get_by_resource_mac.py
+
+ Before run the sample, please set the values of the client ID, tenant ID and client secret
+ of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
+ AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
+ https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
+"""
+
+
+def main():
+ client = AlertsManagementClient(
+ credential=DefaultAzureCredential(),
+ subscription_id="SUBSCRIPTION_ID",
+ )
+
+ response = client.alert_rule_recommendations.list_by_resource(
+ resource_uri="subscriptions/2f00cc51-6809-498f-9ffc-48c42aff570d/resourceGroups/GenevaAlertRP-RunnerResources-eastus/providers/microsoft.monitor/accounts/alertsrp-eastus-pgms",
+ )
+ for item in response:
+ print(item)
+
+
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2023-08-01-preview/examples/AlertRuleRecommendations_GetByResource_MAC.json
+if __name__ == "__main__":
+ main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_rule_recommendations_get_by_resource_vm.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_rule_recommendations_get_by_resource_vm.py
new file mode 100644
index 0000000000000..580b8048ff01c
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_rule_recommendations_get_by_resource_vm.py
@@ -0,0 +1,42 @@
+# 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 azure.identity import DefaultAzureCredential
+
+from azure.mgmt.alertsmanagement import AlertsManagementClient
+
+"""
+# PREREQUISITES
+ pip install azure-identity
+ pip install azure-mgmt-alertsmanagement
+# USAGE
+ python alert_rule_recommendations_get_by_resource_vm.py
+
+ Before run the sample, please set the values of the client ID, tenant ID and client secret
+ of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
+ AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
+ https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
+"""
+
+
+def main():
+ client = AlertsManagementClient(
+ credential=DefaultAzureCredential(),
+ subscription_id="SUBSCRIPTION_ID",
+ )
+
+ response = client.alert_rule_recommendations.list_by_resource(
+ resource_uri="subscriptions/2f00cc51-6809-498f-9ffc-48c42aff570d/resourcegroups/test/providers/Microsoft.Compute/virtualMachines/testMachineCanBeSafelyDeleted",
+ )
+ for item in response:
+ print(item)
+
+
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2023-08-01-preview/examples/AlertRuleRecommendations_GetByResource_VM.json
+if __name__ == "__main__":
+ main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_list_subscription.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_rule_recommendations_get_by_subscription_mac.py
similarity index 77%
rename from sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_list_subscription.py
rename to sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_rule_recommendations_get_by_subscription_mac.py
index f60030923c9ac..339d92cc2c0de 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_list_subscription.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_rule_recommendations_get_by_subscription_mac.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -14,7 +15,7 @@
pip install azure-identity
pip install azure-mgmt-alertsmanagement
# USAGE
- python alert_processing_rules_list_subscription.py
+ python alert_rule_recommendations_get_by_subscription_mac.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
@@ -26,14 +27,16 @@
def main():
client = AlertsManagementClient(
credential=DefaultAzureCredential(),
- subscription_id="1e3ff1c0-771a-4119-a03b-be82a51e232d",
+ subscription_id="2f00cc51-6809-498f-9ffc-48c42aff570d",
)
- response = client.alert_processing_rules.list_by_subscription()
+ response = client.alert_rule_recommendations.list_by_target_type(
+ target_type="microsoft.monitor/accounts",
+ )
for item in response:
print(item)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2021-08-08/examples/AlertProcessingRules_List_Subscription.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2023-08-01-preview/examples/AlertRuleRecommendations_GetBySubscription_MAC.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_get_by_id.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_rule_recommendations_get_by_subscription_vm.py
similarity index 74%
rename from sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_get_by_id.py
rename to sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_rule_recommendations_get_by_subscription_vm.py
index 6e58d707a9465..512ad5f48cbd2 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_get_by_id.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_rule_recommendations_get_by_subscription_vm.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -14,7 +15,7 @@
pip install azure-identity
pip install azure-mgmt-alertsmanagement
# USAGE
- python alert_processing_rules_get_by_id.py
+ python alert_rule_recommendations_get_by_subscription_vm.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
@@ -26,16 +27,16 @@
def main():
client = AlertsManagementClient(
credential=DefaultAzureCredential(),
- subscription_id="1e3ff1c0-771a-4119-a03b-be82a51e232d",
+ subscription_id="2f00cc51-6809-498f-9ffc-48c42aff570d",
)
- response = client.alert_processing_rules.get_by_name(
- resource_group_name="alertscorrelationrg",
- alert_processing_rule_name="DailySuppression",
+ response = client.alert_rule_recommendations.list_by_target_type(
+ target_type="microsoft.compute/virtualmachines",
)
- print(response)
+ for item in response:
+ print(item)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2021-08-08/examples/AlertProcessingRules_GetById.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2023-08-01-preview/examples/AlertRuleRecommendations_GetBySubscription_VM.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_change_state.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_change_state.py
index 97ce6575b964b..30171db57a196 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_change_state.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_change_state.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -26,16 +27,17 @@
def main():
client = AlertsManagementClient(
credential=DefaultAzureCredential(),
- subscription_id="9e261de7-c804-4b9d-9ebf-6f50fe350a9a",
+ subscription_id="SUBSCRIPTION_ID",
)
response = client.alerts.change_state(
+ scope="subscriptions/9e261de7-c804-4b9d-9ebf-6f50fe350a9a",
alert_id="66114d64-d9d9-478b-95c9-b789d6502100",
new_state="Acknowledged",
)
print(response)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2019-05-05-preview/examples/Alerts_ChangeState.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2024-01-01-preview/examples/Alerts_ChangeState.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_get_by_id.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_get_by_id.py
index e4be181c404e2..4f782adf2280e 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_get_by_id.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_get_by_id.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -26,15 +27,16 @@
def main():
client = AlertsManagementClient(
credential=DefaultAzureCredential(),
- subscription_id="9e261de7-c804-4b9d-9ebf-6f50fe350a9a",
+ subscription_id="SUBSCRIPTION_ID",
)
response = client.alerts.get_by_id(
+ scope="subscriptions/9e261de7-c804-4b9d-9ebf-6f50fe350a9a",
alert_id="66114d64-d9d9-478b-95c9-b789d6502100",
)
print(response)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2019-05-05-preview/examples/Alerts_GetById.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2024-01-01-preview/examples/Alerts_GetById.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_delete.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_get_enrichments.py
similarity index 78%
rename from sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_delete.py
rename to sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_get_enrichments.py
index da1035a3ed6b7..bee95c1bda42d 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_delete.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_get_enrichments.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -14,7 +15,7 @@
pip install azure-identity
pip install azure-mgmt-alertsmanagement
# USAGE
- python alert_processing_rules_delete.py
+ python alerts_get_enrichments.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
@@ -26,16 +27,16 @@
def main():
client = AlertsManagementClient(
credential=DefaultAzureCredential(),
- subscription_id="1e3ff1c0-771a-4119-a03b-be82a51e232d",
+ subscription_id="SUBSCRIPTION_ID",
)
- response = client.alert_processing_rules.delete(
- resource_group_name="alertscorrelationrg",
- alert_processing_rule_name="DailySuppression",
+ response = client.alerts.get_enrichments(
+ scope="subscriptions/72fa99ef-9c84-4a7c-b343-ec62da107d81",
+ alert_id="66114d64-d9d9-478b-95c9-b789d6502101",
)
print(response)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2021-08-08/examples/AlertProcessingRules_Delete.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2024-01-01-preview/examples/Alerts_GetEnrichments.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_history.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_history.py
index 3d11c9aa1d136..08033535bf0c8 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_history.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_history.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -26,15 +27,16 @@
def main():
client = AlertsManagementClient(
credential=DefaultAzureCredential(),
- subscription_id="9e261de7-c804-4b9d-9ebf-6f50fe350a9a",
+ subscription_id="SUBSCRIPTION_ID",
)
response = client.alerts.get_history(
+ scope="subscriptions/9e261de7-c804-4b9d-9ebf-6f50fe350a9a",
alert_id="66114d64-d9d9-478b-95c9-b789d6502100",
)
print(response)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2019-05-05-preview/examples/Alerts_History.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2024-01-01-preview/examples/Alerts_History.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_list.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_list.py
index 1aad26234d857..c70a7e0bcd4ea 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_list.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_list.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -26,14 +27,16 @@
def main():
client = AlertsManagementClient(
credential=DefaultAzureCredential(),
- subscription_id="1e3ff1c0-771a-4119-a03b-be82a51e232d",
+ subscription_id="SUBSCRIPTION_ID",
)
- response = client.alerts.get_all()
+ response = client.alerts.get_all(
+ scope="subscriptions/1e3ff1c0-771a-4119-a03b-be82a51e232d",
+ )
for item in response:
print(item)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2019-05-05-preview/examples/Alerts_List.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2024-01-01-preview/examples/Alerts_List.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_list_resource_group.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_list_enrichments.py
similarity index 78%
rename from sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_list_resource_group.py
rename to sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_list_enrichments.py
index df87df4c57e94..8ae5cfccf90a8 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alert_processing_rules_list_resource_group.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_list_enrichments.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -14,7 +15,7 @@
pip install azure-identity
pip install azure-mgmt-alertsmanagement
# USAGE
- python alert_processing_rules_list_resource_group.py
+ python alerts_list_enrichments.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
@@ -26,16 +27,17 @@
def main():
client = AlertsManagementClient(
credential=DefaultAzureCredential(),
- subscription_id="1e3ff1c0-771a-4119-a03b-be82a51e232d",
+ subscription_id="SUBSCRIPTION_ID",
)
- response = client.alert_processing_rules.list_by_resource_group(
- resource_group_name="alertscorrelationrg",
+ response = client.alerts.list_enrichments(
+ scope="subscriptions/72fa99ef-9c84-4a7c-b343-ec62da107d81",
+ alert_id="66114d64-d9d9-478b-95c9-b789d6502101",
)
for item in response:
print(item)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2021-08-08/examples/AlertProcessingRules_List_ResourceGroup.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2024-01-01-preview/examples/Alerts_ListEnrichments.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_meta_data_monitor_service.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_meta_data_monitor_service.py
index 035559a1bbc34..18202fccdef85 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_meta_data_monitor_service.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_meta_data_monitor_service.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -35,6 +36,6 @@ def main():
print(response)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2019-05-05-preview/examples/AlertsMetaData_MonitorService.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2024-01-01-preview/examples/AlertsMetaData_MonitorService.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_summary.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_summary.py
index 8794d5a0df8d7..7d05394ab6bc6 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_summary.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/alerts_summary.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -26,15 +27,16 @@
def main():
client = AlertsManagementClient(
credential=DefaultAzureCredential(),
- subscription_id="1e3ff1c0-771a-4119-a03b-be82a51e232d",
+ subscription_id="SUBSCRIPTION_ID",
)
response = client.alerts.get_summary(
+ scope="subscriptions/1e3ff1c0-771a-4119-a03b-be82a51e232d",
groupby="severity,alertState",
)
print(response)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2019-05-05-preview/examples/Alerts_Summary.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2024-01-01-preview/examples/Alerts_Summary.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/create_or_update_cluster_centric_rule_group.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/create_or_update_cluster_centric_rule_group.py
new file mode 100644
index 0000000000000..2569d191b676a
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/create_or_update_cluster_centric_rule_group.py
@@ -0,0 +1,67 @@
+# 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 azure.identity import DefaultAzureCredential
+
+from azure.mgmt.alertsmanagement import AlertsManagementClient
+
+"""
+# PREREQUISITES
+ pip install azure-identity
+ pip install azure-mgmt-alertsmanagement
+# USAGE
+ python create_or_update_cluster_centric_rule_group.py
+
+ Before run the sample, please set the values of the client ID, tenant ID and client secret
+ of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
+ AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
+ https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
+"""
+
+
+def main():
+ client = AlertsManagementClient(
+ credential=DefaultAzureCredential(),
+ subscription_id="ffffffff-ffff-ffff-ffff-ffffffffffff",
+ )
+
+ response = client.prometheus_rule_groups.create_or_update(
+ resource_group_name="promResourceGroup",
+ rule_group_name="myPrometheusRuleGroup",
+ parameters={
+ "location": "East US",
+ "properties": {
+ "clusterName": "myClusterName",
+ "description": "This is a rule group with culster centric configuration",
+ "interval": "PT10M",
+ "rules": [
+ {
+ "actions": [],
+ "alert": "Billing_Processing_Very_Slow",
+ "annotations": {"annotationName1": "annotationValue1"},
+ "enabled": True,
+ "expression": "job_type:billing_jobs_duration_seconds:99p5m > 30",
+ "for": "PT5M",
+ "labels": {"team": "prod"},
+ "resolveConfiguration": {"autoResolved": True, "timeToResolve": "PT10M"},
+ "severity": 2,
+ }
+ ],
+ "scopes": [
+ "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/myResourceGroup/providers/microsoft.monitor/accounts/myAzureMonitorWorkspace",
+ "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/myResourceGroup/providers/Microsoft.ContainerService/managedClusters/myClusterName",
+ ],
+ },
+ },
+ )
+ print(response)
+
+
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2023-03-01/examples/createOrUpdateClusterCentricRuleGroup.json
+if __name__ == "__main__":
+ main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/create_or_update_prometheus_rule_group.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/create_or_update_prometheus_rule_group.py
index 98dab269a300e..5ee6d2541d9fb 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/create_or_update_prometheus_rule_group.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/create_or_update_prometheus_rule_group.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -26,16 +27,19 @@
def main():
client = AlertsManagementClient(
credential=DefaultAzureCredential(),
- subscription_id="14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7",
+ subscription_id="ffffffff-ffff-ffff-ffff-ffffffffffff",
)
response = client.prometheus_rule_groups.create_or_update(
- resource_group_name="giladstest",
+ resource_group_name="promResourceGroup",
rule_group_name="myPrometheusRuleGroup",
parameters={
"location": "East US",
"properties": {
- "description": "This is the description of the first rule group",
+ "clusterName": "myClusterName",
+ "description": "This is the description of the following rule group",
+ "enabled": True,
+ "interval": "PT10M",
"rules": [
{
"expression": 'histogram_quantile(0.99, sum(rate(jobs_duration_seconds_bucket{service="billing-processing"}[5m])) by (job_type))',
@@ -45,12 +49,17 @@ def main():
{
"actions": [
{
- "actionGroupId": "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/giladstest/providers/microsoft.insights/notificationgroups/group2",
+ "actionGroupId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourcegroups/myrg/providers/microsoft.insights/actiongroups/myactiongroup",
"actionProperties": {"key11": "value11", "key12": "value12"},
- }
+ },
+ {
+ "actionGroupId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourcegroups/myrg/providers/microsoft.insights/actiongroups/myotheractiongroup",
+ "actionProperties": {"key21": "value21", "key22": "value22"},
+ },
],
"alert": "Billing_Processing_Very_Slow",
"annotations": {"annotationName1": "annotationValue1"},
+ "enabled": True,
"expression": "job_type:billing_jobs_duration_seconds:99p5m > 30",
"for": "PT5M",
"labels": {"team": "prod"},
@@ -59,7 +68,7 @@ def main():
},
],
"scopes": [
- "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/giladstest/providers/microsoft.monitor/accounts/myMonitoringAccount"
+ "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/myResourceGroup/providers/microsoft.monitor/accounts/myAzureMonitorWorkspace"
],
},
},
@@ -67,6 +76,6 @@ def main():
print(response)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2021-07-22-preview/examples/createOrUpdatePrometheusRuleGroup.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2023-03-01/examples/createOrUpdatePrometheusRuleGroup.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/delete_prometheus_rule_group.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/delete_prometheus_rule_group.py
index 0c233d48f7534..18350b3eb506a 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/delete_prometheus_rule_group.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/delete_prometheus_rule_group.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -26,16 +27,15 @@
def main():
client = AlertsManagementClient(
credential=DefaultAzureCredential(),
- subscription_id="14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7",
+ subscription_id="ffffffff-ffff-ffff-ffff-ffffffffffff",
)
- response = client.prometheus_rule_groups.delete(
- resource_group_name="giladsteset",
+ client.prometheus_rule_groups.delete(
+ resource_group_name="promResourceGroup",
rule_group_name="myPrometheusRuleGroup",
)
- print(response)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2021-07-22-preview/examples/deletePrometheusRuleGroup.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2023-03-01/examples/deletePrometheusRuleGroup.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/get_prometheus_rule_group.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/get_prometheus_rule_group.py
index 41ae7fa00fe35..b4909305a322f 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/get_prometheus_rule_group.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/get_prometheus_rule_group.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -26,16 +27,16 @@
def main():
client = AlertsManagementClient(
credential=DefaultAzureCredential(),
- subscription_id="14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7",
+ subscription_id="ffffffff-ffff-ffff-ffff-ffffffffffff",
)
response = client.prometheus_rule_groups.get(
- resource_group_name="giladstest",
+ resource_group_name="promResourceGroup",
rule_group_name="myPrometheusRuleGroup",
)
print(response)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2021-07-22-preview/examples/getPrometheusRuleGroup.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2023-03-01/examples/getPrometheusRuleGroup.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/list_prometheus_rule_groups.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/list_prometheus_rule_groups.py
index f300eb020d155..72f6b7f45950b 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/list_prometheus_rule_groups.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/list_prometheus_rule_groups.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -26,16 +27,16 @@
def main():
client = AlertsManagementClient(
credential=DefaultAzureCredential(),
- subscription_id="14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7",
+ subscription_id="ffffffff-ffff-ffff-ffff-ffffffffffff",
)
response = client.prometheus_rule_groups.list_by_resource_group(
- resource_group_name="giladstest",
+ resource_group_name="promResourceGroup",
)
for item in response:
print(item)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2021-07-22-preview/examples/listPrometheusRuleGroups.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2023-03-01/examples/listPrometheusRuleGroups.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/list_subscription_prometheus_rule_groups.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/list_subscription_prometheus_rule_groups.py
index e2ea7530deb20..1883ab25ff964 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/list_subscription_prometheus_rule_groups.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/list_subscription_prometheus_rule_groups.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -26,7 +27,7 @@
def main():
client = AlertsManagementClient(
credential=DefaultAzureCredential(),
- subscription_id="14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7",
+ subscription_id="ffffffff-ffff-ffff-ffff-ffffffffffff",
)
response = client.prometheus_rule_groups.list_by_subscription()
@@ -34,6 +35,6 @@ def main():
print(item)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2021-07-22-preview/examples/listSubscriptionPrometheusRuleGroups.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2023-03-01/examples/listSubscriptionPrometheusRuleGroups.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/operations_list.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/operations_list.py
index 69a32c6a68738..b4d6263fa8b03 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/operations_list.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/operations_list.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -34,6 +35,6 @@ def main():
print(item)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2019-05-05-preview/examples/Operations_List.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2024-01-01-preview/examples/Operations_List.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/patch_prometheus_rule_group.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/patch_prometheus_rule_group.py
index d5d921aa0d340..bde5abb241b75 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/patch_prometheus_rule_group.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/patch_prometheus_rule_group.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
@@ -26,17 +27,17 @@
def main():
client = AlertsManagementClient(
credential=DefaultAzureCredential(),
- subscription_id="14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7",
+ subscription_id="ffffffff-ffff-ffff-ffff-ffffffffffff",
)
response = client.prometheus_rule_groups.update(
- resource_group_name="giladstest",
+ resource_group_name="promResourceGroup",
rule_group_name="myPrometheusRuleGroup",
- parameters={"properties": {"enabled": False}, "tags": {"tag1": "value1"}},
+ parameters={"properties": {"enabled": False}, "tags": {"tag1": "tagValueFromPatch"}},
)
print(response)
-# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/preview/2021-07-22-preview/examples/patchPrometheusRuleGroup.json
+# x-ms-original-file: specification/alertsmanagement/resource-manager/Microsoft.AlertsManagement/stable/2023-03-01/examples/patchPrometheusRuleGroup.json
if __name__ == "__main__":
main()
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_change_state.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_change_state.py
index 7bf44c2b64876..3d0a183eff788 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_change_state.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_change_state.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_get_by_id.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_get_by_id.py
index 27fad7e322b30..e125dee6324f4 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_get_by_id.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_get_by_id.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_history.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_history.py
index 4fedb8a5d1e74..c8d5da586245a 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_history.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_history.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_list.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_list.py
index 229f50a04cda5..e5c51665930d6 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_list.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_samples/smart_groups_list.py
@@ -7,6 +7,7 @@
# --------------------------------------------------------------------------
from azure.identity import DefaultAzureCredential
+
from azure.mgmt.alertsmanagement import AlertsManagementClient
"""
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/conftest.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/conftest.py
new file mode 100644
index 0000000000000..ba19842193495
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/conftest.py
@@ -0,0 +1,35 @@
+# 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 os
+import pytest
+from dotenv import load_dotenv
+from devtools_testutils import (
+ test_proxy,
+ add_general_regex_sanitizer,
+ add_body_key_sanitizer,
+ add_header_regex_sanitizer,
+)
+
+load_dotenv()
+
+
+# For security, please avoid record sensitive identity information in recordings
+@pytest.fixture(scope="session", autouse=True)
+def add_sanitizers(test_proxy):
+ alertsmanagement_subscription_id = os.environ.get("AZURE_SUBSCRIPTION_ID", "00000000-0000-0000-0000-000000000000")
+ alertsmanagement_tenant_id = os.environ.get("AZURE_TENANT_ID", "00000000-0000-0000-0000-000000000000")
+ alertsmanagement_client_id = os.environ.get("AZURE_CLIENT_ID", "00000000-0000-0000-0000-000000000000")
+ alertsmanagement_client_secret = os.environ.get("AZURE_CLIENT_SECRET", "00000000-0000-0000-0000-000000000000")
+ add_general_regex_sanitizer(regex=alertsmanagement_subscription_id, value="00000000-0000-0000-0000-000000000000")
+ add_general_regex_sanitizer(regex=alertsmanagement_tenant_id, value="00000000-0000-0000-0000-000000000000")
+ add_general_regex_sanitizer(regex=alertsmanagement_client_id, value="00000000-0000-0000-0000-000000000000")
+ add_general_regex_sanitizer(regex=alertsmanagement_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;")
+ add_body_key_sanitizer(json_path="$..access_token", value="access_token")
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_alert_rule_recommendations_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_alert_rule_recommendations_operations.py
new file mode 100644
index 0000000000000..5c58b67ea98ba
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_alert_rule_recommendations_operations.py
@@ -0,0 +1,41 @@
+# 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.alertsmanagement import AlertsManagementClient
+
+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 TestAlertsManagementAlertRuleRecommendationsOperations(AzureMgmtRecordedTestCase):
+ def setup_method(self, method):
+ self.client = self.create_mgmt_client(AlertsManagementClient)
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_alert_rule_recommendations_list_by_resource(self, resource_group):
+ response = self.client.alert_rule_recommendations.list_by_resource(
+ resource_uri="str",
+ api_version="2023-08-01-preview",
+ )
+ 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_recommendations_list_by_target_type(self, resource_group):
+ response = self.client.alert_rule_recommendations.list_by_target_type(
+ target_type="str",
+ api_version="2023-08-01-preview",
+ )
+ result = [r for r in response]
+ # please add some check logic here by yourself
+ # ...
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_alert_rule_recommendations_operations_async.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_alert_rule_recommendations_operations_async.py
new file mode 100644
index 0000000000000..7905e3c84f5b3
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_alert_rule_recommendations_operations_async.py
@@ -0,0 +1,42 @@
+# 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.alertsmanagement.aio import AlertsManagementClient
+
+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 TestAlertsManagementAlertRuleRecommendationsOperationsAsync(AzureMgmtRecordedTestCase):
+ def setup_method(self, method):
+ self.client = self.create_mgmt_client(AlertsManagementClient, is_async=True)
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy_async
+ async def test_alert_rule_recommendations_list_by_resource(self, resource_group):
+ response = self.client.alert_rule_recommendations.list_by_resource(
+ resource_uri="str",
+ api_version="2023-08-01-preview",
+ )
+ 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_recommendations_list_by_target_type(self, resource_group):
+ response = self.client.alert_rule_recommendations.list_by_target_type(
+ target_type="str",
+ api_version="2023-08-01-preview",
+ )
+ result = [r async for r in response]
+ # please add some check logic here by yourself
+ # ...
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_alerts_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_alerts_operations.py
new file mode 100644
index 0000000000000..356c0b95d0823
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_alerts_operations.py
@@ -0,0 +1,114 @@
+# 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.alertsmanagement import AlertsManagementClient
+
+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 TestAlertsManagementAlertsOperations(AzureMgmtRecordedTestCase):
+ def setup_method(self, method):
+ self.client = self.create_mgmt_client(AlertsManagementClient)
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_alerts_meta_data(self, resource_group):
+ response = self.client.alerts.meta_data(
+ identifier="str",
+ api_version="2024-01-01-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_alerts_get_all(self, resource_group):
+ response = self.client.alerts.get_all(
+ scope="str",
+ api_version="2024-01-01-preview",
+ )
+ result = [r for r in response]
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_alerts_get_by_id(self, resource_group):
+ response = self.client.alerts.get_by_id(
+ scope="str",
+ alert_id="str",
+ api_version="2024-01-01-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_alerts_change_state(self, resource_group):
+ response = self.client.alerts.change_state(
+ scope="str",
+ alert_id="str",
+ new_state="str",
+ api_version="2024-01-01-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_alerts_get_history(self, resource_group):
+ response = self.client.alerts.get_history(
+ scope="str",
+ alert_id="str",
+ api_version="2024-01-01-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_alerts_get_summary(self, resource_group):
+ response = self.client.alerts.get_summary(
+ scope="str",
+ groupby="str",
+ api_version="2024-01-01-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_alerts_list_enrichments(self, resource_group):
+ response = self.client.alerts.list_enrichments(
+ scope="str",
+ alert_id="str",
+ api_version="2024-01-01-preview",
+ )
+ result = [r for r in response]
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_alerts_get_enrichments(self, resource_group):
+ response = self.client.alerts.get_enrichments(
+ scope="str",
+ alert_id="str",
+ api_version="2024-01-01-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_alerts_operations_async.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_alerts_operations_async.py
new file mode 100644
index 0000000000000..ab9a0e4ab5834
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_alerts_operations_async.py
@@ -0,0 +1,115 @@
+# 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.alertsmanagement.aio import AlertsManagementClient
+
+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 TestAlertsManagementAlertsOperationsAsync(AzureMgmtRecordedTestCase):
+ def setup_method(self, method):
+ self.client = self.create_mgmt_client(AlertsManagementClient, is_async=True)
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy_async
+ async def test_alerts_meta_data(self, resource_group):
+ response = await self.client.alerts.meta_data(
+ identifier="str",
+ api_version="2024-01-01-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy_async
+ async def test_alerts_get_all(self, resource_group):
+ response = self.client.alerts.get_all(
+ scope="str",
+ api_version="2024-01-01-preview",
+ )
+ 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_alerts_get_by_id(self, resource_group):
+ response = await self.client.alerts.get_by_id(
+ scope="str",
+ alert_id="str",
+ api_version="2024-01-01-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy_async
+ async def test_alerts_change_state(self, resource_group):
+ response = await self.client.alerts.change_state(
+ scope="str",
+ alert_id="str",
+ new_state="str",
+ api_version="2024-01-01-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy_async
+ async def test_alerts_get_history(self, resource_group):
+ response = await self.client.alerts.get_history(
+ scope="str",
+ alert_id="str",
+ api_version="2024-01-01-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy_async
+ async def test_alerts_get_summary(self, resource_group):
+ response = await self.client.alerts.get_summary(
+ scope="str",
+ groupby="str",
+ api_version="2024-01-01-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy_async
+ async def test_alerts_list_enrichments(self, resource_group):
+ response = self.client.alerts.list_enrichments(
+ scope="str",
+ alert_id="str",
+ api_version="2024-01-01-preview",
+ )
+ 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_alerts_get_enrichments(self, resource_group):
+ response = await self.client.alerts.get_enrichments(
+ scope="str",
+ alert_id="str",
+ api_version="2024-01-01-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_operations.py
new file mode 100644
index 0000000000000..742a2accb0e1b
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_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.alertsmanagement import AlertsManagementClient
+
+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 TestAlertsManagementOperations(AzureMgmtRecordedTestCase):
+ def setup_method(self, method):
+ self.client = self.create_mgmt_client(AlertsManagementClient)
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_operations_list(self, resource_group):
+ response = self.client.operations.list(
+ api_version="2024-01-01-preview",
+ )
+ result = [r for r in response]
+ # please add some check logic here by yourself
+ # ...
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_operations_async.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_operations_async.py
new file mode 100644
index 0000000000000..378b489699bc0
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_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.alertsmanagement.aio import AlertsManagementClient
+
+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 TestAlertsManagementOperationsAsync(AzureMgmtRecordedTestCase):
+ def setup_method(self, method):
+ self.client = self.create_mgmt_client(AlertsManagementClient, 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="2024-01-01-preview",
+ )
+ result = [r async for r in response]
+ # please add some check logic here by yourself
+ # ...
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_prometheus_rule_groups_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_prometheus_rule_groups_operations.py
new file mode 100644
index 0000000000000..5fe43e09259f0
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_prometheus_rule_groups_operations.py
@@ -0,0 +1,123 @@
+# 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.alertsmanagement import AlertsManagementClient
+
+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 TestAlertsManagementPrometheusRuleGroupsOperations(AzureMgmtRecordedTestCase):
+ def setup_method(self, method):
+ self.client = self.create_mgmt_client(AlertsManagementClient)
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_prometheus_rule_groups_list_by_subscription(self, resource_group):
+ response = self.client.prometheus_rule_groups.list_by_subscription(
+ api_version="2023-03-01",
+ )
+ result = [r for r in response]
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_prometheus_rule_groups_list_by_resource_group(self, resource_group):
+ response = self.client.prometheus_rule_groups.list_by_resource_group(
+ resource_group_name=resource_group.name,
+ api_version="2023-03-01",
+ )
+ result = [r for r in response]
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_prometheus_rule_groups_get(self, resource_group):
+ response = self.client.prometheus_rule_groups.get(
+ resource_group_name=resource_group.name,
+ rule_group_name="str",
+ api_version="2023-03-01",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_prometheus_rule_groups_create_or_update(self, resource_group):
+ response = self.client.prometheus_rule_groups.create_or_update(
+ resource_group_name=resource_group.name,
+ rule_group_name="str",
+ parameters={
+ "location": "str",
+ "rules": [
+ {
+ "expression": "str",
+ "actions": [{"actionGroupId": "str", "actionProperties": {"str": "str"}}],
+ "alert": "str",
+ "annotations": {"str": "str"},
+ "enabled": bool,
+ "for": "1 day, 0:00:00",
+ "labels": {"str": "str"},
+ "record": "str",
+ "resolveConfiguration": {"autoResolved": bool, "timeToResolve": "1 day, 0:00:00"},
+ "severity": 0,
+ }
+ ],
+ "scopes": ["str"],
+ "clusterName": "str",
+ "description": "str",
+ "enabled": bool,
+ "id": "str",
+ "interval": "1 day, 0:00:00",
+ "name": "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="2023-03-01",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_prometheus_rule_groups_update(self, resource_group):
+ response = self.client.prometheus_rule_groups.update(
+ resource_group_name=resource_group.name,
+ rule_group_name="str",
+ parameters={"enabled": bool, "tags": {"str": "str"}},
+ api_version="2023-03-01",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_prometheus_rule_groups_delete(self, resource_group):
+ response = self.client.prometheus_rule_groups.delete(
+ resource_group_name=resource_group.name,
+ rule_group_name="str",
+ api_version="2023-03-01",
+ )
+
+ # please add some check logic here by yourself
+ # ...
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_prometheus_rule_groups_operations_async.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_prometheus_rule_groups_operations_async.py
new file mode 100644
index 0000000000000..d393c9e085501
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_prometheus_rule_groups_operations_async.py
@@ -0,0 +1,124 @@
+# 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.alertsmanagement.aio import AlertsManagementClient
+
+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 TestAlertsManagementPrometheusRuleGroupsOperationsAsync(AzureMgmtRecordedTestCase):
+ def setup_method(self, method):
+ self.client = self.create_mgmt_client(AlertsManagementClient, is_async=True)
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy_async
+ async def test_prometheus_rule_groups_list_by_subscription(self, resource_group):
+ response = self.client.prometheus_rule_groups.list_by_subscription(
+ api_version="2023-03-01",
+ )
+ 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_prometheus_rule_groups_list_by_resource_group(self, resource_group):
+ response = self.client.prometheus_rule_groups.list_by_resource_group(
+ resource_group_name=resource_group.name,
+ api_version="2023-03-01",
+ )
+ 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_prometheus_rule_groups_get(self, resource_group):
+ response = await self.client.prometheus_rule_groups.get(
+ resource_group_name=resource_group.name,
+ rule_group_name="str",
+ api_version="2023-03-01",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy_async
+ async def test_prometheus_rule_groups_create_or_update(self, resource_group):
+ response = await self.client.prometheus_rule_groups.create_or_update(
+ resource_group_name=resource_group.name,
+ rule_group_name="str",
+ parameters={
+ "location": "str",
+ "rules": [
+ {
+ "expression": "str",
+ "actions": [{"actionGroupId": "str", "actionProperties": {"str": "str"}}],
+ "alert": "str",
+ "annotations": {"str": "str"},
+ "enabled": bool,
+ "for": "1 day, 0:00:00",
+ "labels": {"str": "str"},
+ "record": "str",
+ "resolveConfiguration": {"autoResolved": bool, "timeToResolve": "1 day, 0:00:00"},
+ "severity": 0,
+ }
+ ],
+ "scopes": ["str"],
+ "clusterName": "str",
+ "description": "str",
+ "enabled": bool,
+ "id": "str",
+ "interval": "1 day, 0:00:00",
+ "name": "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="2023-03-01",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy_async
+ async def test_prometheus_rule_groups_update(self, resource_group):
+ response = await self.client.prometheus_rule_groups.update(
+ resource_group_name=resource_group.name,
+ rule_group_name="str",
+ parameters={"enabled": bool, "tags": {"str": "str"}},
+ api_version="2023-03-01",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy_async
+ async def test_prometheus_rule_groups_delete(self, resource_group):
+ response = await self.client.prometheus_rule_groups.delete(
+ resource_group_name=resource_group.name,
+ rule_group_name="str",
+ api_version="2023-03-01",
+ )
+
+ # please add some check logic here by yourself
+ # ...
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_smart_groups_operations.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_smart_groups_operations.py
new file mode 100644
index 0000000000000..50afe45b42768
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_smart_groups_operations.py
@@ -0,0 +1,63 @@
+# 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.alertsmanagement import AlertsManagementClient
+
+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 TestAlertsManagementSmartGroupsOperations(AzureMgmtRecordedTestCase):
+ def setup_method(self, method):
+ self.client = self.create_mgmt_client(AlertsManagementClient)
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_smart_groups_get_all(self, resource_group):
+ response = self.client.smart_groups.get_all(
+ api_version="2019-05-05-preview",
+ )
+ result = [r for r in response]
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_smart_groups_get_by_id(self, resource_group):
+ response = self.client.smart_groups.get_by_id(
+ smart_group_id="str",
+ api_version="2019-05-05-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_smart_groups_change_state(self, resource_group):
+ response = self.client.smart_groups.change_state(
+ smart_group_id="str",
+ new_state="str",
+ api_version="2019-05-05-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy
+ def test_smart_groups_get_history(self, resource_group):
+ response = self.client.smart_groups.get_history(
+ smart_group_id="str",
+ api_version="2019-05-05-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_smart_groups_operations_async.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_smart_groups_operations_async.py
new file mode 100644
index 0000000000000..7f696f2e22a21
--- /dev/null
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/generated_tests/test_alerts_management_smart_groups_operations_async.py
@@ -0,0 +1,64 @@
+# 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.alertsmanagement.aio import AlertsManagementClient
+
+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 TestAlertsManagementSmartGroupsOperationsAsync(AzureMgmtRecordedTestCase):
+ def setup_method(self, method):
+ self.client = self.create_mgmt_client(AlertsManagementClient, is_async=True)
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy_async
+ async def test_smart_groups_get_all(self, resource_group):
+ response = self.client.smart_groups.get_all(
+ api_version="2019-05-05-preview",
+ )
+ 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_smart_groups_get_by_id(self, resource_group):
+ response = await self.client.smart_groups.get_by_id(
+ smart_group_id="str",
+ api_version="2019-05-05-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy_async
+ async def test_smart_groups_change_state(self, resource_group):
+ response = await self.client.smart_groups.change_state(
+ smart_group_id="str",
+ new_state="str",
+ api_version="2019-05-05-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
+
+ @RandomNameResourceGroupPreparer(location=AZURE_LOCATION)
+ @recorded_by_proxy_async
+ async def test_smart_groups_get_history(self, resource_group):
+ response = await self.client.smart_groups.get_history(
+ smart_group_id="str",
+ api_version="2019-05-05-preview",
+ )
+
+ # please add some check logic here by yourself
+ # ...
diff --git a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/setup.py b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/setup.py
index 5d5ea95810ada..812865133853d 100644
--- a/sdk/alertsmanagement/azure-mgmt-alertsmanagement/setup.py
+++ b/sdk/alertsmanagement/azure-mgmt-alertsmanagement/setup.py
@@ -1,10 +1,10 @@
#!/usr/bin/env python
-#-------------------------------------------------------------------------
+# -------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
-#--------------------------------------------------------------------------
+# --------------------------------------------------------------------------
import re
import os.path
@@ -16,64 +16,68 @@
PACKAGE_PPRINT_NAME = "Alerts Management"
# a-b-c => a/b/c
-package_folder_path = PACKAGE_NAME.replace('-', '/')
+package_folder_path = PACKAGE_NAME.replace("-", "/")
# a-b-c => a.b.c
-namespace_name = PACKAGE_NAME.replace('-', '.')
+namespace_name = PACKAGE_NAME.replace("-", ".")
# Version extraction inspired from 'requests'
-with open(os.path.join(package_folder_path, 'version.py')
- if os.path.exists(os.path.join(package_folder_path, 'version.py'))
- else os.path.join(package_folder_path, '_version.py'), 'r') as fd:
- version = re.search(r'^VERSION\s*=\s*[\'"]([^\'"]*)[\'"]',
- fd.read(), re.MULTILINE).group(1)
+with open(
+ os.path.join(package_folder_path, "version.py")
+ if os.path.exists(os.path.join(package_folder_path, "version.py"))
+ else os.path.join(package_folder_path, "_version.py"),
+ "r",
+) as fd:
+ version = re.search(r'^VERSION\s*=\s*[\'"]([^\'"]*)[\'"]', fd.read(), re.MULTILINE).group(1)
if not version:
- raise RuntimeError('Cannot find version information')
+ raise RuntimeError("Cannot find version information")
-with open('README.md', encoding='utf-8') as f:
+with open("README.md", encoding="utf-8") as f:
readme = f.read()
-with open('CHANGELOG.md', encoding='utf-8') as f:
+with open("CHANGELOG.md", encoding="utf-8") as f:
changelog = f.read()
setup(
name=PACKAGE_NAME,
version=version,
- description='Microsoft Azure {} Client Library for Python'.format(PACKAGE_PPRINT_NAME),
- long_description=readme + '\n\n' + changelog,
- long_description_content_type='text/markdown',
- license='MIT License',
- author='Microsoft Corporation',
- author_email='azpysdkhelp@microsoft.com',
- url='https://github.com/Azure/azure-sdk-for-python',
+ description="Microsoft Azure {} Client Library for Python".format(PACKAGE_PPRINT_NAME),
+ long_description=readme + "\n\n" + changelog,
+ long_description_content_type="text/markdown",
+ license="MIT License",
+ author="Microsoft Corporation",
+ author_email="azpysdkhelp@microsoft.com",
+ 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',
- 'Programming Language :: Python',
- 'Programming Language :: Python :: 3 :: Only',
- 'Programming Language :: Python :: 3',
- 'Programming Language :: Python :: 3.7',
- 'Programming Language :: Python :: 3.8',
- 'Programming Language :: Python :: 3.9',
- 'Programming Language :: Python :: 3.10',
- 'Programming Language :: Python :: 3.11',
- 'License :: OSI Approved :: MIT License',
+ "Development Status :: 4 - Beta",
+ "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",
+ "Programming Language :: Python :: 3.12",
+ "License :: OSI Approved :: MIT License",
],
zip_safe=False,
- packages=find_packages(exclude=[
- 'tests',
- # Exclude packages that will be covered by PEP420 or nspkg
- 'azure',
- 'azure.mgmt',
- ]),
+ packages=find_packages(
+ exclude=[
+ "tests",
+ # Exclude packages that will be covered by PEP420 or nspkg
+ "azure",
+ "azure.mgmt",
+ ]
+ ),
include_package_data=True,
package_data={
- 'pytyped': ['py.typed'],
+ "pytyped": ["py.typed"],
},
install_requires=[
- "msrest>=0.7.1",
- "azure-common~=1.1",
- "azure-mgmt-core>=1.3.2,<2.0.0",
- "typing-extensions>=4.3.0; python_version<'3.8.0'",
+ "isodate>=0.6.1",
+ "typing-extensions>=4.6.0",
+ "azure-common>=1.1",
+ "azure-mgmt-core>=1.3.2",
],
- python_requires=">=3.7"
+ python_requires=">=3.8",
)