From b64d818b7382657ea9da42565bb5dae7f59e1a32 Mon Sep 17 00:00:00 2001 From: SDKAuto Date: Thu, 15 Sep 2022 02:30:05 +0000 Subject: [PATCH] CodeGen from PR 20628 in Azure/azure-rest-api-specs Merge c4311290e27eb0e03727e728b828cb467e91101b into b749953e21e5c3f275d839862323920ef7bf716e --- sdk/advisor/azure-mgmt-advisor/_meta.json | 11 + .../azure/mgmt/advisor/__init__.py | 13 +- .../advisor/_advisor_management_client.py | 101 +- .../azure/mgmt/advisor/_configuration.py | 58 +- .../azure/mgmt/advisor/_patch.py | 20 + .../azure/mgmt/advisor/_serialization.py | 1970 +++++++++++++++++ .../azure/mgmt/advisor/_vendor.py | 47 + .../azure/mgmt/advisor/_version.py | 2 +- .../azure/mgmt/advisor/aio/__init__.py | 13 +- .../advisor/aio/_advisor_management_client.py | 90 +- .../azure/mgmt/advisor/aio/_configuration.py | 55 +- .../azure/mgmt/advisor/aio/_patch.py | 20 + .../azure/mgmt/advisor/aio/_vendor.py | 28 + .../mgmt/advisor/aio/operations/__init__.py | 18 +- .../_advisor_management_client_operations.py | 147 ++ .../operations/_configurations_operations.py | 535 +++-- .../advisor/aio/operations/_operations.py | 126 +- .../mgmt/advisor/aio/operations/_patch.py | 20 + .../_recommendation_metadata_operations.py | 205 +- .../operations/_recommendations_operations.py | 352 +-- .../operations/_suppressions_operations.py | 492 ++-- .../azure/mgmt/advisor/models/__init__.py | 135 +- .../_advisor_management_client_enums.py | 69 +- .../azure/mgmt/advisor/models/_models.py | 362 ++- .../azure/mgmt/advisor/models/_models_py3.py | 926 +++++--- .../azure/mgmt/advisor/models/_patch.py | 20 + .../azure/mgmt/advisor/operations/__init__.py | 18 +- .../_advisor_management_client_operations.py | 176 ++ .../operations/_configurations_operations.py | 666 ++++-- .../mgmt/advisor/operations/_operations.py | 156 +- .../azure/mgmt/advisor/operations/_patch.py | 20 + .../_recommendation_metadata_operations.py | 257 ++- .../operations/_recommendations_operations.py | 475 ++-- .../operations/_suppressions_operations.py | 624 ++++-- 34 files changed, 6085 insertions(+), 2142 deletions(-) create mode 100644 sdk/advisor/azure-mgmt-advisor/_meta.json create mode 100644 sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_patch.py create mode 100644 sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_serialization.py create mode 100644 sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_vendor.py create mode 100644 sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_patch.py create mode 100644 sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_vendor.py create mode 100644 sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_advisor_management_client_operations.py create mode 100644 sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_patch.py create mode 100644 sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_patch.py create mode 100644 sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_advisor_management_client_operations.py create mode 100644 sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_patch.py diff --git a/sdk/advisor/azure-mgmt-advisor/_meta.json b/sdk/advisor/azure-mgmt-advisor/_meta.json new file mode 100644 index 0000000000000..eca1fecff1dce --- /dev/null +++ b/sdk/advisor/azure-mgmt-advisor/_meta.json @@ -0,0 +1,11 @@ +{ + "autorest": "3.8.4", + "use": [ + "@autorest/python@6.1.5", + "@autorest/modelerfour@4.23.5" + ], + "commit": "b6e9cae715e06ea8c989ad48658ab109d9194b45", + "repository_url": "https://github.com/Azure/azure-rest-api-specs", + "autorest_command": "autorest specification/advisor/resource-manager/readme.md --python --python-sdks-folder=/mnt/vss/_work/1/s/azure-sdk-for-python/sdk --use=@autorest/python@6.1.5 --use=@autorest/modelerfour@4.23.5 --version=3.8.4 --version-tolerant=False", + "readme": "specification/advisor/resource-manager/readme.md" +} \ No newline at end of file diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/__init__.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/__init__.py index ce9602fc01435..37b7925ff128a 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/__init__.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/__init__.py @@ -10,10 +10,15 @@ from ._version import VERSION __version__ = VERSION -__all__ = ['AdvisorManagementClient'] try: - from ._patch import patch_sdk # type: ignore - patch_sdk() + from ._patch import __all__ as _patch_all + from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import except ImportError: - pass + _patch_all = [] +from ._patch import patch_sdk as _patch_sdk + +__all__ = ["AdvisorManagementClient"] +__all__.extend([p for p in _patch_all if p not in __all__]) + +_patch_sdk() diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_advisor_management_client.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_advisor_management_client.py index 3247b8cc14181..f61eb29fac48e 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_advisor_management_client.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_advisor_management_client.py @@ -6,31 +6,37 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING +from copy import deepcopy +from typing import Any, TYPE_CHECKING +from azure.core.rest import HttpRequest, HttpResponse from azure.mgmt.core import ARMPipelineClient -from msrest import Deserializer, Serializer + +from . import models +from ._configuration import AdvisorManagementClientConfiguration +from ._serialization import Deserializer, Serializer +from .operations import ( + AdvisorManagementClientOperationsMixin, + ConfigurationsOperations, + Operations, + RecommendationMetadataOperations, + RecommendationsOperations, + SuppressionsOperations, +) if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - from typing import Any, Optional - from azure.core.credentials import TokenCredential -from ._configuration import AdvisorManagementClientConfiguration -from .operations import RecommendationMetadataOperations -from .operations import ConfigurationsOperations -from .operations import RecommendationsOperations -from .operations import Operations -from .operations import SuppressionsOperations -from . import models - -class AdvisorManagementClient(object): +class AdvisorManagementClient( + AdvisorManagementClientOperationsMixin +): # pylint: disable=client-accepts-api-version-keyword """REST APIs for Azure Advisor. :ivar recommendation_metadata: RecommendationMetadataOperations operations - :vartype recommendation_metadata: azure.mgmt.advisor.operations.RecommendationMetadataOperations + :vartype recommendation_metadata: + azure.mgmt.advisor.operations.RecommendationMetadataOperations :ivar configurations: ConfigurationsOperations operations :vartype configurations: azure.mgmt.advisor.operations.ConfigurationsOperations :ivar recommendations: RecommendationsOperations operations @@ -39,41 +45,62 @@ class AdvisorManagementClient(object): :vartype operations: azure.mgmt.advisor.operations.Operations :ivar suppressions: SuppressionsOperations operations :vartype suppressions: azure.mgmt.advisor.operations.SuppressionsOperations - :param credential: Credential needed for the client to connect to Azure. + :param credential: Credential needed for the client to connect to Azure. Required. :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: The Azure subscription ID. + :param subscription_id: The Azure subscription ID. Required. :type subscription_id: str - :param str base_url: Service URL + :param base_url: Service URL. Default value is "https://management.azure.com". + :type base_url: str + :keyword api_version: Api Version. Default value is "2022-09-01". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str """ def __init__( self, - credential, # type: "TokenCredential" - subscription_id, # type: str - base_url=None, # type: Optional[str] - **kwargs # type: Any - ): - # type: (...) -> None - if not base_url: - base_url = 'https://management.azure.com' - self._config = AdvisorManagementClientConfiguration(credential, subscription_id, **kwargs) + credential: "TokenCredential", + subscription_id: str, + base_url: str = "https://management.azure.com", + **kwargs: Any + ) -> None: + self._config = AdvisorManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = ARMPipelineClient(base_url=base_url, config=self._config, **kwargs) client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) - self._serialize.client_side_validation = False self._deserialize = Deserializer(client_models) - + self._serialize.client_side_validation = False self.recommendation_metadata = RecommendationMetadataOperations( - self._client, self._config, self._serialize, self._deserialize) - self.configurations = ConfigurationsOperations( - self._client, self._config, self._serialize, self._deserialize) - self.recommendations = RecommendationsOperations( - self._client, self._config, self._serialize, self._deserialize) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize) - self.suppressions = SuppressionsOperations( - self._client, self._config, self._serialize, self._deserialize) + self._client, self._config, self._serialize, self._deserialize + ) + self.configurations = ConfigurationsOperations(self._client, self._config, self._serialize, self._deserialize) + self.recommendations = RecommendationsOperations(self._client, self._config, self._serialize, self._deserialize) + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) + self.suppressions = SuppressionsOperations(self._client, self._config, self._serialize, self._deserialize) + + def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: + """Runs the network request through the client's chained policies. + + >>> from azure.core.rest import HttpRequest + >>> request = HttpRequest("GET", "https://www.example.org/") + + >>> response = client._send_request(request) + + + For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request + + :param request: The network request you want to make. Required. + :type request: ~azure.core.rest.HttpRequest + :keyword bool stream: Whether the response payload will be streamed. Defaults to False. + :return: The response of your network call. Does not do error handling on your response. + :rtype: ~azure.core.rest.HttpResponse + """ + + request_copy = deepcopy(request) + request_copy.url = self._client.format_url(request_copy.url) + return self._client.send_request(request_copy, **kwargs) def close(self): # type: () -> None diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_configuration.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_configuration.py index 702eb8c152855..31c57927037c7 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_configuration.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_configuration.py @@ -6,66 +6,64 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING +from typing import Any, TYPE_CHECKING from azure.core.configuration import Configuration from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMHttpLoggingPolicy +from azure.mgmt.core.policies import ARMChallengeAuthenticationPolicy, ARMHttpLoggingPolicy from ._version import VERSION if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - from typing import Any - from azure.core.credentials import TokenCredential -class AdvisorManagementClientConfiguration(Configuration): +class AdvisorManagementClientConfiguration(Configuration): # pylint: disable=too-many-instance-attributes """Configuration for AdvisorManagementClient. Note that all parameters used to create this instance are saved as instance attributes. - :param credential: Credential needed for the client to connect to Azure. + :param credential: Credential needed for the client to connect to Azure. Required. :type credential: ~azure.core.credentials.TokenCredential - :param subscription_id: The Azure subscription ID. + :param subscription_id: The Azure subscription ID. Required. :type subscription_id: str + :keyword api_version: Api Version. Default value is "2022-09-01". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str """ - def __init__( - self, - credential, # type: "TokenCredential" - subscription_id, # type: str - **kwargs # type: Any - ): - # type: (...) -> None + def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: + super(AdvisorManagementClientConfiguration, self).__init__(**kwargs) + api_version = kwargs.pop("api_version", "2022-09-01") # type: str + if credential is None: raise ValueError("Parameter 'credential' must not be None.") if subscription_id is None: raise ValueError("Parameter 'subscription_id' must not be None.") - super(AdvisorManagementClientConfiguration, self).__init__(**kwargs) self.credential = credential self.subscription_id = subscription_id - self.api_version = "2020-01-01" - self.credential_scopes = kwargs.pop('credential_scopes', ['https://management.azure.com/.default']) - kwargs.setdefault('sdk_moniker', 'mgmt-advisor/{}'.format(VERSION)) + self.api_version = api_version + self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-advisor/{}".format(VERSION)) self._configure(**kwargs) def _configure( - self, - **kwargs # type: Any + self, **kwargs # type: Any ): # type: (...) -> None - self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) - self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) - self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) - self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) - self.http_logging_policy = kwargs.get('http_logging_policy') or ARMHttpLoggingPolicy(**kwargs) - self.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + self.user_agent_policy = kwargs.get("user_agent_policy") or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get("headers_policy") or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs) + self.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs) + self.authentication_policy = kwargs.get("authentication_policy") if self.credential and not self.authentication_policy: - self.authentication_policy = policies.BearerTokenCredentialPolicy(self.credential, *self.credential_scopes, **kwargs) + self.authentication_policy = ARMChallengeAuthenticationPolicy( + self.credential, *self.credential_scopes, **kwargs + ) diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_patch.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_patch.py new file mode 100644 index 0000000000000..f7dd32510333d --- /dev/null +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_serialization.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_serialization.py new file mode 100644 index 0000000000000..7c1dedb5133d3 --- /dev/null +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_serialization.py @@ -0,0 +1,1970 @@ +# -------------------------------------------------------------------------- +# +# Copyright (c) Microsoft Corporation. All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the ""Software""), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. +# +# -------------------------------------------------------------------------- + +# pylint: skip-file + +from base64 import b64decode, b64encode +import calendar +import datetime +import decimal +import email +from enum import Enum +import json +import logging +import re +import sys +import codecs + +try: + from urllib import quote # type: ignore +except ImportError: + from urllib.parse import quote # type: ignore +import xml.etree.ElementTree as ET + +import isodate + +from typing import Dict, Any, cast, TYPE_CHECKING + +from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback + +_BOM = codecs.BOM_UTF8.decode(encoding="utf-8") + +if TYPE_CHECKING: + from typing import Optional, Union, AnyStr, IO, Mapping + + +class RawDeserializer: + + # Accept "text" because we're open minded people... + JSON_REGEXP = re.compile(r"^(application|text)/([a-z+.]+\+)?json$") + + # Name used in context + CONTEXT_NAME = "deserialized_data" + + @classmethod + def deserialize_from_text(cls, data, content_type=None): + # type: (Optional[Union[AnyStr, IO]], Optional[str]) -> Any + """Decode data according to content-type. + + Accept a stream of data as well, but will be load at once in memory for now. + + If no content-type, will return the string version (not bytes, not stream) + + :param data: Input, could be bytes or stream (will be decoded with UTF8) or text + :type data: str or bytes or IO + :param str content_type: The content type. + """ + if hasattr(data, "read"): + # Assume a stream + data = cast(IO, data).read() + + if isinstance(data, bytes): + data_as_str = data.decode(encoding="utf-8-sig") + else: + # Explain to mypy the correct type. + data_as_str = cast(str, data) + + # Remove Byte Order Mark if present in string + data_as_str = data_as_str.lstrip(_BOM) + + if content_type is None: + return data + + if cls.JSON_REGEXP.match(content_type): + try: + return json.loads(data_as_str) + except ValueError as err: + raise DeserializationError("JSON is invalid: {}".format(err), err) + elif "xml" in (content_type or []): + try: + + try: + if isinstance(data, unicode): # type: ignore + # If I'm Python 2.7 and unicode XML will scream if I try a "fromstring" on unicode string + data_as_str = data_as_str.encode(encoding="utf-8") # type: ignore + except NameError: + pass + + return ET.fromstring(data_as_str) # nosec + except ET.ParseError: + # It might be because the server has an issue, and returned JSON with + # content-type XML.... + # So let's try a JSON load, and if it's still broken + # let's flow the initial exception + def _json_attemp(data): + try: + return True, json.loads(data) + except ValueError: + return False, None # Don't care about this one + + success, json_result = _json_attemp(data) + if success: + return json_result + # If i'm here, it's not JSON, it's not XML, let's scream + # and raise the last context in this block (the XML exception) + # The function hack is because Py2.7 messes up with exception + # context otherwise. + _LOGGER.critical("Wasn't XML not JSON, failing") + raise_with_traceback(DeserializationError, "XML is invalid") + raise DeserializationError("Cannot deserialize content-type: {}".format(content_type)) + + @classmethod + def deserialize_from_http_generics(cls, body_bytes, headers): + # type: (Optional[Union[AnyStr, IO]], Mapping) -> Any + """Deserialize from HTTP response. + + Use bytes and headers to NOT use any requests/aiohttp or whatever + specific implementation. + Headers will tested for "content-type" + """ + # Try to use content-type from headers if available + content_type = None + if "content-type" in headers: + content_type = headers["content-type"].split(";")[0].strip().lower() + # Ouch, this server did not declare what it sent... + # Let's guess it's JSON... + # Also, since Autorest was considering that an empty body was a valid JSON, + # need that test as well.... + else: + content_type = "application/json" + + if body_bytes: + return cls.deserialize_from_text(body_bytes, content_type) + return None + + +try: + basestring # type: ignore + unicode_str = unicode # type: ignore +except NameError: + basestring = str # type: ignore + unicode_str = str # type: ignore + +_LOGGER = logging.getLogger(__name__) + +try: + _long_type = long # type: ignore +except NameError: + _long_type = int + + +class UTC(datetime.tzinfo): + """Time Zone info for handling UTC""" + + def utcoffset(self, dt): + """UTF offset for UTC is 0.""" + return datetime.timedelta(0) + + def tzname(self, dt): + """Timestamp representation.""" + return "Z" + + def dst(self, dt): + """No daylight saving for UTC.""" + return datetime.timedelta(hours=1) + + +try: + from datetime import timezone as _FixedOffset +except ImportError: # Python 2.7 + + class _FixedOffset(datetime.tzinfo): # type: ignore + """Fixed offset in minutes east from UTC. + Copy/pasted from Python doc + :param datetime.timedelta offset: offset in timedelta format + """ + + def __init__(self, offset): + self.__offset = offset + + def utcoffset(self, dt): + return self.__offset + + def tzname(self, dt): + return str(self.__offset.total_seconds() / 3600) + + def __repr__(self): + return "".format(self.tzname(None)) + + def dst(self, dt): + return datetime.timedelta(0) + + def __getinitargs__(self): + return (self.__offset,) + + +try: + from datetime import timezone + + TZ_UTC = timezone.utc # type: ignore +except ImportError: + TZ_UTC = UTC() # type: ignore + +_FLATTEN = re.compile(r"(? y, + "minimum": lambda x, y: x < y, + "maximum": lambda x, y: x > y, + "minimum_ex": lambda x, y: x <= y, + "maximum_ex": lambda x, y: x >= y, + "min_items": lambda x, y: len(x) < y, + "max_items": lambda x, y: len(x) > y, + "pattern": lambda x, y: not re.match(y, x, re.UNICODE), + "unique": lambda x, y: len(x) != len(set(x)), + "multiple": lambda x, y: x % y != 0, + } + + def __init__(self, classes=None): + self.serialize_type = { + "iso-8601": Serializer.serialize_iso, + "rfc-1123": Serializer.serialize_rfc, + "unix-time": Serializer.serialize_unix, + "duration": Serializer.serialize_duration, + "date": Serializer.serialize_date, + "time": Serializer.serialize_time, + "decimal": Serializer.serialize_decimal, + "long": Serializer.serialize_long, + "bytearray": Serializer.serialize_bytearray, + "base64": Serializer.serialize_base64, + "object": self.serialize_object, + "[]": self.serialize_iter, + "{}": self.serialize_dict, + } + self.dependencies = dict(classes) if classes else {} + self.key_transformer = full_restapi_key_transformer + self.client_side_validation = True + + def _serialize(self, target_obj, data_type=None, **kwargs): + """Serialize data into a string according to type. + + :param target_obj: The data to be serialized. + :param str data_type: The type to be serialized from. + :rtype: str, dict + :raises: SerializationError if serialization fails. + """ + key_transformer = kwargs.get("key_transformer", self.key_transformer) + keep_readonly = kwargs.get("keep_readonly", False) + if target_obj is None: + return None + + attr_name = None + class_name = target_obj.__class__.__name__ + + if data_type: + return self.serialize_data(target_obj, data_type, **kwargs) + + if not hasattr(target_obj, "_attribute_map"): + data_type = type(target_obj).__name__ + if data_type in self.basic_types.values(): + return self.serialize_data(target_obj, data_type, **kwargs) + + # Force "is_xml" kwargs if we detect a XML model + try: + is_xml_model_serialization = kwargs["is_xml"] + except KeyError: + is_xml_model_serialization = kwargs.setdefault("is_xml", target_obj.is_xml_model()) + + serialized = {} + if is_xml_model_serialization: + serialized = target_obj._create_xml_node() + try: + attributes = target_obj._attribute_map + for attr, attr_desc in attributes.items(): + attr_name = attr + if not keep_readonly and target_obj._validation.get(attr_name, {}).get("readonly", False): + continue + + if attr_name == "additional_properties" and attr_desc["key"] == "": + if target_obj.additional_properties is not None: + serialized.update(target_obj.additional_properties) + continue + try: + + orig_attr = getattr(target_obj, attr) + if is_xml_model_serialization: + pass # Don't provide "transformer" for XML for now. Keep "orig_attr" + else: # JSON + keys, orig_attr = key_transformer(attr, attr_desc.copy(), orig_attr) + keys = keys if isinstance(keys, list) else [keys] + + kwargs["serialization_ctxt"] = attr_desc + new_attr = self.serialize_data(orig_attr, attr_desc["type"], **kwargs) + + if is_xml_model_serialization: + xml_desc = attr_desc.get("xml", {}) + xml_name = xml_desc.get("name", attr_desc["key"]) + xml_prefix = xml_desc.get("prefix", None) + xml_ns = xml_desc.get("ns", None) + if xml_desc.get("attr", False): + if xml_ns: + ET.register_namespace(xml_prefix, xml_ns) + xml_name = "{}{}".format(xml_ns, xml_name) + serialized.set(xml_name, new_attr) + continue + if xml_desc.get("text", False): + serialized.text = new_attr + continue + if isinstance(new_attr, list): + serialized.extend(new_attr) + elif isinstance(new_attr, ET.Element): + # If the down XML has no XML/Name, we MUST replace the tag with the local tag. But keeping the namespaces. + if "name" not in getattr(orig_attr, "_xml_map", {}): + splitted_tag = new_attr.tag.split("}") + if len(splitted_tag) == 2: # Namespace + new_attr.tag = "}".join([splitted_tag[0], xml_name]) + else: + new_attr.tag = xml_name + serialized.append(new_attr) + else: # That's a basic type + # Integrate namespace if necessary + local_node = _create_xml_node(xml_name, xml_prefix, xml_ns) + local_node.text = unicode_str(new_attr) + serialized.append(local_node) + else: # JSON + for k in reversed(keys): + unflattened = {k: new_attr} + new_attr = unflattened + + _new_attr = new_attr + _serialized = serialized + for k in keys: + if k not in _serialized: + _serialized.update(_new_attr) + _new_attr = _new_attr[k] + _serialized = _serialized[k] + except ValueError: + continue + + except (AttributeError, KeyError, TypeError) as err: + msg = "Attribute {} in object {} cannot be serialized.\n{}".format(attr_name, class_name, str(target_obj)) + raise_with_traceback(SerializationError, msg, err) + else: + return serialized + + def body(self, data, data_type, **kwargs): + """Serialize data intended for a request body. + + :param data: The data to be serialized. + :param str data_type: The type to be serialized from. + :rtype: dict + :raises: SerializationError if serialization fails. + :raises: ValueError if data is None + """ + + # Just in case this is a dict + internal_data_type = data_type.strip("[]{}") + internal_data_type = self.dependencies.get(internal_data_type, None) + try: + is_xml_model_serialization = kwargs["is_xml"] + except KeyError: + if internal_data_type and issubclass(internal_data_type, Model): + is_xml_model_serialization = kwargs.setdefault("is_xml", internal_data_type.is_xml_model()) + else: + is_xml_model_serialization = False + if internal_data_type and not isinstance(internal_data_type, Enum): + try: + deserializer = Deserializer(self.dependencies) + # Since it's on serialization, it's almost sure that format is not JSON REST + # We're not able to deal with additional properties for now. + deserializer.additional_properties_detection = False + if is_xml_model_serialization: + deserializer.key_extractors = [ + attribute_key_case_insensitive_extractor, + ] + else: + deserializer.key_extractors = [ + rest_key_case_insensitive_extractor, + attribute_key_case_insensitive_extractor, + last_rest_key_case_insensitive_extractor, + ] + data = deserializer._deserialize(data_type, data) + except DeserializationError as err: + raise_with_traceback(SerializationError, "Unable to build a model: " + str(err), err) + + return self._serialize(data, data_type, **kwargs) + + def url(self, name, data, data_type, **kwargs): + """Serialize data intended for a URL path. + + :param data: The data to be serialized. + :param str data_type: The type to be serialized from. + :rtype: str + :raises: TypeError if serialization fails. + :raises: ValueError if data is None + """ + try: + output = self.serialize_data(data, data_type, **kwargs) + if data_type == "bool": + output = json.dumps(output) + + if kwargs.get("skip_quote") is True: + output = str(output) + else: + output = quote(str(output), safe="") + except SerializationError: + raise TypeError("{} must be type {}.".format(name, data_type)) + else: + return output + + def query(self, name, data, data_type, **kwargs): + """Serialize data intended for a URL query. + + :param data: The data to be serialized. + :param str data_type: The type to be serialized from. + :rtype: str + :raises: TypeError if serialization fails. + :raises: ValueError if data is None + """ + try: + # Treat the list aside, since we don't want to encode the div separator + if data_type.startswith("["): + internal_data_type = data_type[1:-1] + data = [self.serialize_data(d, internal_data_type, **kwargs) if d is not None else "" for d in data] + if not kwargs.get("skip_quote", False): + data = [quote(str(d), safe="") for d in data] + return str(self.serialize_iter(data, internal_data_type, **kwargs)) + + # Not a list, regular serialization + output = self.serialize_data(data, data_type, **kwargs) + if data_type == "bool": + output = json.dumps(output) + if kwargs.get("skip_quote") is True: + output = str(output) + else: + output = quote(str(output), safe="") + except SerializationError: + raise TypeError("{} must be type {}.".format(name, data_type)) + else: + return str(output) + + def header(self, name, data, data_type, **kwargs): + """Serialize data intended for a request header. + + :param data: The data to be serialized. + :param str data_type: The type to be serialized from. + :rtype: str + :raises: TypeError if serialization fails. + :raises: ValueError if data is None + """ + try: + if data_type in ["[str]"]: + data = ["" if d is None else d for d in data] + + output = self.serialize_data(data, data_type, **kwargs) + if data_type == "bool": + output = json.dumps(output) + except SerializationError: + raise TypeError("{} must be type {}.".format(name, data_type)) + else: + return str(output) + + def serialize_data(self, data, data_type, **kwargs): + """Serialize generic data according to supplied data type. + + :param data: The data to be serialized. + :param str data_type: The type to be serialized from. + :param bool required: Whether it's essential that the data not be + empty or None + :raises: AttributeError if required data is None. + :raises: ValueError if data is None + :raises: SerializationError if serialization fails. + """ + if data is None: + raise ValueError("No value for given attribute") + + try: + if data_type in self.basic_types.values(): + return self.serialize_basic(data, data_type, **kwargs) + + elif data_type in self.serialize_type: + return self.serialize_type[data_type](data, **kwargs) + + # If dependencies is empty, try with current data class + # It has to be a subclass of Enum anyway + enum_type = self.dependencies.get(data_type, data.__class__) + if issubclass(enum_type, Enum): + return Serializer.serialize_enum(data, enum_obj=enum_type) + + iter_type = data_type[0] + data_type[-1] + if iter_type in self.serialize_type: + return self.serialize_type[iter_type](data, data_type[1:-1], **kwargs) + + except (ValueError, TypeError) as err: + msg = "Unable to serialize value: {!r} as type: {!r}." + raise_with_traceback(SerializationError, msg.format(data, data_type), err) + else: + return self._serialize(data, **kwargs) + + @classmethod + def _get_custom_serializers(cls, data_type, **kwargs): + custom_serializer = kwargs.get("basic_types_serializers", {}).get(data_type) + if custom_serializer: + return custom_serializer + if kwargs.get("is_xml", False): + return cls._xml_basic_types_serializers.get(data_type) + + @classmethod + def serialize_basic(cls, data, data_type, **kwargs): + """Serialize basic builting data type. + Serializes objects to str, int, float or bool. + + Possible kwargs: + - basic_types_serializers dict[str, callable] : If set, use the callable as serializer + - is_xml bool : If set, use xml_basic_types_serializers + + :param data: Object to be serialized. + :param str data_type: Type of object in the iterable. + """ + custom_serializer = cls._get_custom_serializers(data_type, **kwargs) + if custom_serializer: + return custom_serializer(data) + if data_type == "str": + return cls.serialize_unicode(data) + return eval(data_type)(data) # nosec + + @classmethod + def serialize_unicode(cls, data): + """Special handling for serializing unicode strings in Py2. + Encode to UTF-8 if unicode, otherwise handle as a str. + + :param data: Object to be serialized. + :rtype: str + """ + try: # If I received an enum, return its value + return data.value + except AttributeError: + pass + + try: + if isinstance(data, unicode): + # Don't change it, JSON and XML ElementTree are totally able + # to serialize correctly u'' strings + return data + except NameError: + return str(data) + else: + return str(data) + + def serialize_iter(self, data, iter_type, div=None, **kwargs): + """Serialize iterable. + + Supported kwargs: + - serialization_ctxt dict : The current entry of _attribute_map, or same format. + serialization_ctxt['type'] should be same as data_type. + - is_xml bool : If set, serialize as XML + + :param list attr: Object to be serialized. + :param str iter_type: Type of object in the iterable. + :param bool required: Whether the objects in the iterable must + not be None or empty. + :param str div: If set, this str will be used to combine the elements + in the iterable into a combined string. Default is 'None'. + :rtype: list, str + """ + if isinstance(data, str): + raise SerializationError("Refuse str type as a valid iter type.") + + serialization_ctxt = kwargs.get("serialization_ctxt", {}) + is_xml = kwargs.get("is_xml", False) + + serialized = [] + for d in data: + try: + serialized.append(self.serialize_data(d, iter_type, **kwargs)) + except ValueError: + serialized.append(None) + + if div: + serialized = ["" if s is None else str(s) for s in serialized] + serialized = div.join(serialized) + + if "xml" in serialization_ctxt or is_xml: + # XML serialization is more complicated + xml_desc = serialization_ctxt.get("xml", {}) + xml_name = xml_desc.get("name") + if not xml_name: + xml_name = serialization_ctxt["key"] + + # Create a wrap node if necessary (use the fact that Element and list have "append") + is_wrapped = xml_desc.get("wrapped", False) + node_name = xml_desc.get("itemsName", xml_name) + if is_wrapped: + final_result = _create_xml_node(xml_name, xml_desc.get("prefix", None), xml_desc.get("ns", None)) + else: + final_result = [] + # All list elements to "local_node" + for el in serialized: + if isinstance(el, ET.Element): + el_node = el + else: + el_node = _create_xml_node(node_name, xml_desc.get("prefix", None), xml_desc.get("ns", None)) + if el is not None: # Otherwise it writes "None" :-p + el_node.text = str(el) + final_result.append(el_node) + return final_result + return serialized + + def serialize_dict(self, attr, dict_type, **kwargs): + """Serialize a dictionary of objects. + + :param dict attr: Object to be serialized. + :param str dict_type: Type of object in the dictionary. + :param bool required: Whether the objects in the dictionary must + not be None or empty. + :rtype: dict + """ + serialization_ctxt = kwargs.get("serialization_ctxt", {}) + serialized = {} + for key, value in attr.items(): + try: + serialized[self.serialize_unicode(key)] = self.serialize_data(value, dict_type, **kwargs) + except ValueError: + serialized[self.serialize_unicode(key)] = None + + if "xml" in serialization_ctxt: + # XML serialization is more complicated + xml_desc = serialization_ctxt["xml"] + xml_name = xml_desc["name"] + + final_result = _create_xml_node(xml_name, xml_desc.get("prefix", None), xml_desc.get("ns", None)) + for key, value in serialized.items(): + ET.SubElement(final_result, key).text = value + return final_result + + return serialized + + def serialize_object(self, attr, **kwargs): + """Serialize a generic object. + This will be handled as a dictionary. If object passed in is not + a basic type (str, int, float, dict, list) it will simply be + cast to str. + + :param dict attr: Object to be serialized. + :rtype: dict or str + """ + if attr is None: + return None + if isinstance(attr, ET.Element): + return attr + obj_type = type(attr) + if obj_type in self.basic_types: + return self.serialize_basic(attr, self.basic_types[obj_type], **kwargs) + if obj_type is _long_type: + return self.serialize_long(attr) + if obj_type is unicode_str: + return self.serialize_unicode(attr) + if obj_type is datetime.datetime: + return self.serialize_iso(attr) + if obj_type is datetime.date: + return self.serialize_date(attr) + if obj_type is datetime.time: + return self.serialize_time(attr) + if obj_type is datetime.timedelta: + return self.serialize_duration(attr) + if obj_type is decimal.Decimal: + return self.serialize_decimal(attr) + + # If it's a model or I know this dependency, serialize as a Model + elif obj_type in self.dependencies.values() or isinstance(attr, Model): + return self._serialize(attr) + + if obj_type == dict: + serialized = {} + for key, value in attr.items(): + try: + serialized[self.serialize_unicode(key)] = self.serialize_object(value, **kwargs) + except ValueError: + serialized[self.serialize_unicode(key)] = None + return serialized + + if obj_type == list: + serialized = [] + for obj in attr: + try: + serialized.append(self.serialize_object(obj, **kwargs)) + except ValueError: + pass + return serialized + return str(attr) + + @staticmethod + def serialize_enum(attr, enum_obj=None): + try: + result = attr.value + except AttributeError: + result = attr + try: + enum_obj(result) + return result + except ValueError: + for enum_value in enum_obj: + if enum_value.value.lower() == str(attr).lower(): + return enum_value.value + error = "{!r} is not valid value for enum {!r}" + raise SerializationError(error.format(attr, enum_obj)) + + @staticmethod + def serialize_bytearray(attr, **kwargs): + """Serialize bytearray into base-64 string. + + :param attr: Object to be serialized. + :rtype: str + """ + return b64encode(attr).decode() + + @staticmethod + def serialize_base64(attr, **kwargs): + """Serialize str into base-64 string. + + :param attr: Object to be serialized. + :rtype: str + """ + encoded = b64encode(attr).decode("ascii") + return encoded.strip("=").replace("+", "-").replace("/", "_") + + @staticmethod + def serialize_decimal(attr, **kwargs): + """Serialize Decimal object to float. + + :param attr: Object to be serialized. + :rtype: float + """ + return float(attr) + + @staticmethod + def serialize_long(attr, **kwargs): + """Serialize long (Py2) or int (Py3). + + :param attr: Object to be serialized. + :rtype: int/long + """ + return _long_type(attr) + + @staticmethod + def serialize_date(attr, **kwargs): + """Serialize Date object into ISO-8601 formatted string. + + :param Date attr: Object to be serialized. + :rtype: str + """ + if isinstance(attr, str): + attr = isodate.parse_date(attr) + t = "{:04}-{:02}-{:02}".format(attr.year, attr.month, attr.day) + return t + + @staticmethod + def serialize_time(attr, **kwargs): + """Serialize Time object into ISO-8601 formatted string. + + :param datetime.time attr: Object to be serialized. + :rtype: str + """ + if isinstance(attr, str): + attr = isodate.parse_time(attr) + t = "{:02}:{:02}:{:02}".format(attr.hour, attr.minute, attr.second) + if attr.microsecond: + t += ".{:02}".format(attr.microsecond) + return t + + @staticmethod + def serialize_duration(attr, **kwargs): + """Serialize TimeDelta object into ISO-8601 formatted string. + + :param TimeDelta attr: Object to be serialized. + :rtype: str + """ + if isinstance(attr, str): + attr = isodate.parse_duration(attr) + return isodate.duration_isoformat(attr) + + @staticmethod + def serialize_rfc(attr, **kwargs): + """Serialize Datetime object into RFC-1123 formatted string. + + :param Datetime attr: Object to be serialized. + :rtype: str + :raises: TypeError if format invalid. + """ + try: + if not attr.tzinfo: + _LOGGER.warning("Datetime with no tzinfo will be considered UTC.") + utc = attr.utctimetuple() + except AttributeError: + raise TypeError("RFC1123 object must be valid Datetime object.") + + return "{}, {:02} {} {:04} {:02}:{:02}:{:02} GMT".format( + Serializer.days[utc.tm_wday], + utc.tm_mday, + Serializer.months[utc.tm_mon], + utc.tm_year, + utc.tm_hour, + utc.tm_min, + utc.tm_sec, + ) + + @staticmethod + def serialize_iso(attr, **kwargs): + """Serialize Datetime object into ISO-8601 formatted string. + + :param Datetime attr: Object to be serialized. + :rtype: str + :raises: SerializationError if format invalid. + """ + if isinstance(attr, str): + attr = isodate.parse_datetime(attr) + try: + if not attr.tzinfo: + _LOGGER.warning("Datetime with no tzinfo will be considered UTC.") + utc = attr.utctimetuple() + if utc.tm_year > 9999 or utc.tm_year < 1: + raise OverflowError("Hit max or min date") + + microseconds = str(attr.microsecond).rjust(6, "0").rstrip("0").ljust(3, "0") + if microseconds: + microseconds = "." + microseconds + date = "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}".format( + utc.tm_year, utc.tm_mon, utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec + ) + return date + microseconds + "Z" + except (ValueError, OverflowError) as err: + msg = "Unable to serialize datetime object." + raise_with_traceback(SerializationError, msg, err) + except AttributeError as err: + msg = "ISO-8601 object must be valid Datetime object." + raise_with_traceback(TypeError, msg, err) + + @staticmethod + def serialize_unix(attr, **kwargs): + """Serialize Datetime object into IntTime format. + This is represented as seconds. + + :param Datetime attr: Object to be serialized. + :rtype: int + :raises: SerializationError if format invalid + """ + if isinstance(attr, int): + return attr + try: + if not attr.tzinfo: + _LOGGER.warning("Datetime with no tzinfo will be considered UTC.") + return int(calendar.timegm(attr.utctimetuple())) + except AttributeError: + raise TypeError("Unix time object must be valid Datetime object.") + + +def rest_key_extractor(attr, attr_desc, data): + key = attr_desc["key"] + working_data = data + + while "." in key: + dict_keys = _FLATTEN.split(key) + if len(dict_keys) == 1: + key = _decode_attribute_map_key(dict_keys[0]) + break + working_key = _decode_attribute_map_key(dict_keys[0]) + working_data = working_data.get(working_key, data) + if working_data is None: + # If at any point while following flatten JSON path see None, it means + # that all properties under are None as well + # https://github.com/Azure/msrest-for-python/issues/197 + return None + key = ".".join(dict_keys[1:]) + + return working_data.get(key) + + +def rest_key_case_insensitive_extractor(attr, attr_desc, data): + key = attr_desc["key"] + working_data = data + + while "." in key: + dict_keys = _FLATTEN.split(key) + if len(dict_keys) == 1: + key = _decode_attribute_map_key(dict_keys[0]) + break + working_key = _decode_attribute_map_key(dict_keys[0]) + working_data = attribute_key_case_insensitive_extractor(working_key, None, working_data) + if working_data is None: + # If at any point while following flatten JSON path see None, it means + # that all properties under are None as well + # https://github.com/Azure/msrest-for-python/issues/197 + return None + key = ".".join(dict_keys[1:]) + + if working_data: + return attribute_key_case_insensitive_extractor(key, None, working_data) + + +def last_rest_key_extractor(attr, attr_desc, data): + """Extract the attribute in "data" based on the last part of the JSON path key.""" + key = attr_desc["key"] + dict_keys = _FLATTEN.split(key) + return attribute_key_extractor(dict_keys[-1], None, data) + + +def last_rest_key_case_insensitive_extractor(attr, attr_desc, data): + """Extract the attribute in "data" based on the last part of the JSON path key. + + This is the case insensitive version of "last_rest_key_extractor" + """ + key = attr_desc["key"] + dict_keys = _FLATTEN.split(key) + return attribute_key_case_insensitive_extractor(dict_keys[-1], None, data) + + +def attribute_key_extractor(attr, _, data): + return data.get(attr) + + +def attribute_key_case_insensitive_extractor(attr, _, data): + found_key = None + lower_attr = attr.lower() + for key in data: + if lower_attr == key.lower(): + found_key = key + break + + return data.get(found_key) + + +def _extract_name_from_internal_type(internal_type): + """Given an internal type XML description, extract correct XML name with namespace. + + :param dict internal_type: An model type + :rtype: tuple + :returns: A tuple XML name + namespace dict + """ + internal_type_xml_map = getattr(internal_type, "_xml_map", {}) + xml_name = internal_type_xml_map.get("name", internal_type.__name__) + xml_ns = internal_type_xml_map.get("ns", None) + if xml_ns: + xml_name = "{}{}".format(xml_ns, xml_name) + return xml_name + + +def xml_key_extractor(attr, attr_desc, data): + if isinstance(data, dict): + return None + + # Test if this model is XML ready first + if not isinstance(data, ET.Element): + return None + + xml_desc = attr_desc.get("xml", {}) + xml_name = xml_desc.get("name", attr_desc["key"]) + + # Look for a children + is_iter_type = attr_desc["type"].startswith("[") + is_wrapped = xml_desc.get("wrapped", False) + internal_type = attr_desc.get("internalType", None) + internal_type_xml_map = getattr(internal_type, "_xml_map", {}) + + # Integrate namespace if necessary + xml_ns = xml_desc.get("ns", internal_type_xml_map.get("ns", None)) + if xml_ns: + xml_name = "{}{}".format(xml_ns, xml_name) + + # If it's an attribute, that's simple + if xml_desc.get("attr", False): + return data.get(xml_name) + + # If it's x-ms-text, that's simple too + if xml_desc.get("text", False): + return data.text + + # Scenario where I take the local name: + # - Wrapped node + # - Internal type is an enum (considered basic types) + # - Internal type has no XML/Name node + if is_wrapped or (internal_type and (issubclass(internal_type, Enum) or "name" not in internal_type_xml_map)): + children = data.findall(xml_name) + # If internal type has a local name and it's not a list, I use that name + elif not is_iter_type and internal_type and "name" in internal_type_xml_map: + xml_name = _extract_name_from_internal_type(internal_type) + children = data.findall(xml_name) + # That's an array + else: + if internal_type: # Complex type, ignore itemsName and use the complex type name + items_name = _extract_name_from_internal_type(internal_type) + else: + items_name = xml_desc.get("itemsName", xml_name) + children = data.findall(items_name) + + if len(children) == 0: + if is_iter_type: + if is_wrapped: + return None # is_wrapped no node, we want None + else: + return [] # not wrapped, assume empty list + return None # Assume it's not there, maybe an optional node. + + # If is_iter_type and not wrapped, return all found children + if is_iter_type: + if not is_wrapped: + return children + else: # Iter and wrapped, should have found one node only (the wrap one) + if len(children) != 1: + raise DeserializationError( + "Tried to deserialize an array not wrapped, and found several nodes '{}'. Maybe you should declare this array as wrapped?".format( + xml_name + ) + ) + return list(children[0]) # Might be empty list and that's ok. + + # Here it's not a itertype, we should have found one element only or empty + if len(children) > 1: + raise DeserializationError("Find several XML '{}' where it was not expected".format(xml_name)) + return children[0] + + +class Deserializer(object): + """Response object model deserializer. + + :param dict classes: Class type dictionary for deserializing complex types. + :ivar list key_extractors: Ordered list of extractors to be used by this deserializer. + """ + + basic_types = {str: "str", int: "int", bool: "bool", float: "float"} + + valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?") + + def __init__(self, classes=None): + self.deserialize_type = { + "iso-8601": Deserializer.deserialize_iso, + "rfc-1123": Deserializer.deserialize_rfc, + "unix-time": Deserializer.deserialize_unix, + "duration": Deserializer.deserialize_duration, + "date": Deserializer.deserialize_date, + "time": Deserializer.deserialize_time, + "decimal": Deserializer.deserialize_decimal, + "long": Deserializer.deserialize_long, + "bytearray": Deserializer.deserialize_bytearray, + "base64": Deserializer.deserialize_base64, + "object": self.deserialize_object, + "[]": self.deserialize_iter, + "{}": self.deserialize_dict, + } + self.deserialize_expected_types = { + "duration": (isodate.Duration, datetime.timedelta), + "iso-8601": (datetime.datetime), + } + self.dependencies = dict(classes) if classes else {} + self.key_extractors = [rest_key_extractor, xml_key_extractor] + # Additional properties only works if the "rest_key_extractor" is used to + # extract the keys. Making it to work whatever the key extractor is too much + # complicated, with no real scenario for now. + # So adding a flag to disable additional properties detection. This flag should be + # used if your expect the deserialization to NOT come from a JSON REST syntax. + # Otherwise, result are unexpected + self.additional_properties_detection = True + + def __call__(self, target_obj, response_data, content_type=None): + """Call the deserializer to process a REST response. + + :param str target_obj: Target data type to deserialize to. + :param requests.Response response_data: REST response object. + :param str content_type: Swagger "produces" if available. + :raises: DeserializationError if deserialization fails. + :return: Deserialized object. + """ + data = self._unpack_content(response_data, content_type) + return self._deserialize(target_obj, data) + + def _deserialize(self, target_obj, data): + """Call the deserializer on a model. + + Data needs to be already deserialized as JSON or XML ElementTree + + :param str target_obj: Target data type to deserialize to. + :param object data: Object to deserialize. + :raises: DeserializationError if deserialization fails. + :return: Deserialized object. + """ + # This is already a model, go recursive just in case + if hasattr(data, "_attribute_map"): + constants = [name for name, config in getattr(data, "_validation", {}).items() if config.get("constant")] + try: + for attr, mapconfig in data._attribute_map.items(): + if attr in constants: + continue + value = getattr(data, attr) + if value is None: + continue + local_type = mapconfig["type"] + internal_data_type = local_type.strip("[]{}") + if internal_data_type not in self.dependencies or isinstance(internal_data_type, Enum): + continue + setattr(data, attr, self._deserialize(local_type, value)) + return data + except AttributeError: + return + + response, class_name = self._classify_target(target_obj, data) + + if isinstance(response, basestring): + return self.deserialize_data(data, response) + elif isinstance(response, type) and issubclass(response, Enum): + return self.deserialize_enum(data, response) + + if data is None: + return data + try: + attributes = response._attribute_map + d_attrs = {} + for attr, attr_desc in attributes.items(): + # Check empty string. If it's not empty, someone has a real "additionalProperties"... + if attr == "additional_properties" and attr_desc["key"] == "": + continue + raw_value = None + # Enhance attr_desc with some dynamic data + attr_desc = attr_desc.copy() # Do a copy, do not change the real one + internal_data_type = attr_desc["type"].strip("[]{}") + if internal_data_type in self.dependencies: + attr_desc["internalType"] = self.dependencies[internal_data_type] + + for key_extractor in self.key_extractors: + found_value = key_extractor(attr, attr_desc, data) + if found_value is not None: + if raw_value is not None and raw_value != found_value: + msg = ( + "Ignoring extracted value '%s' from %s for key '%s'" + " (duplicate extraction, follow extractors order)" + ) + _LOGGER.warning(msg, found_value, key_extractor, attr) + continue + raw_value = found_value + + value = self.deserialize_data(raw_value, attr_desc["type"]) + d_attrs[attr] = value + except (AttributeError, TypeError, KeyError) as err: + msg = "Unable to deserialize to object: " + class_name + raise_with_traceback(DeserializationError, msg, err) + else: + additional_properties = self._build_additional_properties(attributes, data) + return self._instantiate_model(response, d_attrs, additional_properties) + + def _build_additional_properties(self, attribute_map, data): + if not self.additional_properties_detection: + return None + if "additional_properties" in attribute_map and attribute_map.get("additional_properties", {}).get("key") != "": + # Check empty string. If it's not empty, someone has a real "additionalProperties" + return None + if isinstance(data, ET.Element): + data = {el.tag: el.text for el in data} + + known_keys = { + _decode_attribute_map_key(_FLATTEN.split(desc["key"])[0]) + for desc in attribute_map.values() + if desc["key"] != "" + } + present_keys = set(data.keys()) + missing_keys = present_keys - known_keys + return {key: data[key] for key in missing_keys} + + def _classify_target(self, target, data): + """Check to see whether the deserialization target object can + be classified into a subclass. + Once classification has been determined, initialize object. + + :param str target: The target object type to deserialize to. + :param str/dict data: The response data to deseralize. + """ + if target is None: + return None, None + + if isinstance(target, basestring): + try: + target = self.dependencies[target] + except KeyError: + return target, target + + try: + target = target._classify(data, self.dependencies) + except AttributeError: + pass # Target is not a Model, no classify + return target, target.__class__.__name__ + + def failsafe_deserialize(self, target_obj, data, content_type=None): + """Ignores any errors encountered in deserialization, + and falls back to not deserializing the object. Recommended + for use in error deserialization, as we want to return the + HttpResponseError to users, and not have them deal with + a deserialization error. + + :param str target_obj: The target object type to deserialize to. + :param str/dict data: The response data to deseralize. + :param str content_type: Swagger "produces" if available. + """ + try: + return self(target_obj, data, content_type=content_type) + except: + _LOGGER.debug( + "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True + ) + return None + + @staticmethod + def _unpack_content(raw_data, content_type=None): + """Extract the correct structure for deserialization. + + If raw_data is a PipelineResponse, try to extract the result of RawDeserializer. + if we can't, raise. Your Pipeline should have a RawDeserializer. + + If not a pipeline response and raw_data is bytes or string, use content-type + to decode it. If no content-type, try JSON. + + If raw_data is something else, bypass all logic and return it directly. + + :param raw_data: Data to be processed. + :param content_type: How to parse if raw_data is a string/bytes. + :raises JSONDecodeError: If JSON is requested and parsing is impossible. + :raises UnicodeDecodeError: If bytes is not UTF8 + """ + # Assume this is enough to detect a Pipeline Response without importing it + context = getattr(raw_data, "context", {}) + if context: + if RawDeserializer.CONTEXT_NAME in context: + return context[RawDeserializer.CONTEXT_NAME] + raise ValueError("This pipeline didn't have the RawDeserializer policy; can't deserialize") + + # Assume this is enough to recognize universal_http.ClientResponse without importing it + if hasattr(raw_data, "body"): + return RawDeserializer.deserialize_from_http_generics(raw_data.text(), raw_data.headers) + + # Assume this enough to recognize requests.Response without importing it. + if hasattr(raw_data, "_content_consumed"): + return RawDeserializer.deserialize_from_http_generics(raw_data.text, raw_data.headers) + + if isinstance(raw_data, (basestring, bytes)) or hasattr(raw_data, "read"): + return RawDeserializer.deserialize_from_text(raw_data, content_type) + return raw_data + + def _instantiate_model(self, response, attrs, additional_properties=None): + """Instantiate a response model passing in deserialized args. + + :param response: The response model class. + :param d_attrs: The deserialized response attributes. + """ + if callable(response): + subtype = getattr(response, "_subtype_map", {}) + try: + readonly = [k for k, v in response._validation.items() if v.get("readonly")] + const = [k for k, v in response._validation.items() if v.get("constant")] + kwargs = {k: v for k, v in attrs.items() if k not in subtype and k not in readonly + const} + response_obj = response(**kwargs) + for attr in readonly: + setattr(response_obj, attr, attrs.get(attr)) + if additional_properties: + response_obj.additional_properties = additional_properties + return response_obj + except TypeError as err: + msg = "Unable to deserialize {} into model {}. ".format(kwargs, response) + raise DeserializationError(msg + str(err)) + else: + try: + for attr, value in attrs.items(): + setattr(response, attr, value) + return response + except Exception as exp: + msg = "Unable to populate response model. " + msg += "Type: {}, Error: {}".format(type(response), exp) + raise DeserializationError(msg) + + def deserialize_data(self, data, data_type): + """Process data for deserialization according to data type. + + :param str data: The response string to be deserialized. + :param str data_type: The type to deserialize to. + :raises: DeserializationError if deserialization fails. + :return: Deserialized object. + """ + if data is None: + return data + + try: + if not data_type: + return data + if data_type in self.basic_types.values(): + return self.deserialize_basic(data, data_type) + if data_type in self.deserialize_type: + if isinstance(data, self.deserialize_expected_types.get(data_type, tuple())): + return data + + is_a_text_parsing_type = lambda x: x not in ["object", "[]", r"{}"] + if isinstance(data, ET.Element) and is_a_text_parsing_type(data_type) and not data.text: + return None + data_val = self.deserialize_type[data_type](data) + return data_val + + iter_type = data_type[0] + data_type[-1] + if iter_type in self.deserialize_type: + return self.deserialize_type[iter_type](data, data_type[1:-1]) + + obj_type = self.dependencies[data_type] + if issubclass(obj_type, Enum): + if isinstance(data, ET.Element): + data = data.text + return self.deserialize_enum(data, obj_type) + + except (ValueError, TypeError, AttributeError) as err: + msg = "Unable to deserialize response data." + msg += " Data: {}, {}".format(data, data_type) + raise_with_traceback(DeserializationError, msg, err) + else: + return self._deserialize(obj_type, data) + + def deserialize_iter(self, attr, iter_type): + """Deserialize an iterable. + + :param list attr: Iterable to be deserialized. + :param str iter_type: The type of object in the iterable. + :rtype: list + """ + if attr is None: + return None + if isinstance(attr, ET.Element): # If I receive an element here, get the children + attr = list(attr) + if not isinstance(attr, (list, set)): + raise DeserializationError("Cannot deserialize as [{}] an object of type {}".format(iter_type, type(attr))) + return [self.deserialize_data(a, iter_type) for a in attr] + + def deserialize_dict(self, attr, dict_type): + """Deserialize a dictionary. + + :param dict/list attr: Dictionary to be deserialized. Also accepts + a list of key, value pairs. + :param str dict_type: The object type of the items in the dictionary. + :rtype: dict + """ + if isinstance(attr, list): + return {x["key"]: self.deserialize_data(x["value"], dict_type) for x in attr} + + if isinstance(attr, ET.Element): + # Transform value into {"Key": "value"} + attr = {el.tag: el.text for el in attr} + return {k: self.deserialize_data(v, dict_type) for k, v in attr.items()} + + def deserialize_object(self, attr, **kwargs): + """Deserialize a generic object. + This will be handled as a dictionary. + + :param dict attr: Dictionary to be deserialized. + :rtype: dict + :raises: TypeError if non-builtin datatype encountered. + """ + if attr is None: + return None + if isinstance(attr, ET.Element): + # Do no recurse on XML, just return the tree as-is + return attr + if isinstance(attr, basestring): + return self.deserialize_basic(attr, "str") + obj_type = type(attr) + if obj_type in self.basic_types: + return self.deserialize_basic(attr, self.basic_types[obj_type]) + if obj_type is _long_type: + return self.deserialize_long(attr) + + if obj_type == dict: + deserialized = {} + for key, value in attr.items(): + try: + deserialized[key] = self.deserialize_object(value, **kwargs) + except ValueError: + deserialized[key] = None + return deserialized + + if obj_type == list: + deserialized = [] + for obj in attr: + try: + deserialized.append(self.deserialize_object(obj, **kwargs)) + except ValueError: + pass + return deserialized + + else: + error = "Cannot deserialize generic object with type: " + raise TypeError(error + str(obj_type)) + + def deserialize_basic(self, attr, data_type): + """Deserialize basic builtin data type from string. + Will attempt to convert to str, int, float and bool. + This function will also accept '1', '0', 'true' and 'false' as + valid bool values. + + :param str attr: response string to be deserialized. + :param str data_type: deserialization data type. + :rtype: str, int, float or bool + :raises: TypeError if string format is not valid. + """ + # If we're here, data is supposed to be a basic type. + # If it's still an XML node, take the text + if isinstance(attr, ET.Element): + attr = attr.text + if not attr: + if data_type == "str": + # None or '', node is empty string. + return "" + else: + # None or '', node with a strong type is None. + # Don't try to model "empty bool" or "empty int" + return None + + if data_type == "bool": + if attr in [True, False, 1, 0]: + return bool(attr) + elif isinstance(attr, basestring): + if attr.lower() in ["true", "1"]: + return True + elif attr.lower() in ["false", "0"]: + return False + raise TypeError("Invalid boolean value: {}".format(attr)) + + if data_type == "str": + return self.deserialize_unicode(attr) + return eval(data_type)(attr) # nosec + + @staticmethod + def deserialize_unicode(data): + """Preserve unicode objects in Python 2, otherwise return data + as a string. + + :param str data: response string to be deserialized. + :rtype: str or unicode + """ + # We might be here because we have an enum modeled as string, + # and we try to deserialize a partial dict with enum inside + if isinstance(data, Enum): + return data + + # Consider this is real string + try: + if isinstance(data, unicode): + return data + except NameError: + return str(data) + else: + return str(data) + + @staticmethod + def deserialize_enum(data, enum_obj): + """Deserialize string into enum object. + + If the string is not a valid enum value it will be returned as-is + and a warning will be logged. + + :param str data: Response string to be deserialized. If this value is + None or invalid it will be returned as-is. + :param Enum enum_obj: Enum object to deserialize to. + :rtype: Enum + """ + if isinstance(data, enum_obj) or data is None: + return data + if isinstance(data, Enum): + data = data.value + if isinstance(data, int): + # Workaround. We might consider remove it in the future. + # https://github.com/Azure/azure-rest-api-specs/issues/141 + try: + return list(enum_obj.__members__.values())[data] + except IndexError: + error = "{!r} is not a valid index for enum {!r}" + raise DeserializationError(error.format(data, enum_obj)) + try: + return enum_obj(str(data)) + except ValueError: + for enum_value in enum_obj: + if enum_value.value.lower() == str(data).lower(): + return enum_value + # We don't fail anymore for unknown value, we deserialize as a string + _LOGGER.warning("Deserializer is not able to find %s as valid enum in %s", data, enum_obj) + return Deserializer.deserialize_unicode(data) + + @staticmethod + def deserialize_bytearray(attr): + """Deserialize string into bytearray. + + :param str attr: response string to be deserialized. + :rtype: bytearray + :raises: TypeError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + return bytearray(b64decode(attr)) + + @staticmethod + def deserialize_base64(attr): + """Deserialize base64 encoded string into string. + + :param str attr: response string to be deserialized. + :rtype: bytearray + :raises: TypeError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + padding = "=" * (3 - (len(attr) + 3) % 4) + attr = attr + padding + encoded = attr.replace("-", "+").replace("_", "/") + return b64decode(encoded) + + @staticmethod + def deserialize_decimal(attr): + """Deserialize string into Decimal object. + + :param str attr: response string to be deserialized. + :rtype: Decimal + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + return decimal.Decimal(attr) + except decimal.DecimalException as err: + msg = "Invalid decimal {}".format(attr) + raise_with_traceback(DeserializationError, msg, err) + + @staticmethod + def deserialize_long(attr): + """Deserialize string into long (Py2) or int (Py3). + + :param str attr: response string to be deserialized. + :rtype: long or int + :raises: ValueError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + return _long_type(attr) + + @staticmethod + def deserialize_duration(attr): + """Deserialize ISO-8601 formatted string into TimeDelta object. + + :param str attr: response string to be deserialized. + :rtype: TimeDelta + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + duration = isodate.parse_duration(attr) + except (ValueError, OverflowError, AttributeError) as err: + msg = "Cannot deserialize duration object." + raise_with_traceback(DeserializationError, msg, err) + else: + return duration + + @staticmethod + def deserialize_date(attr): + """Deserialize ISO-8601 formatted string into Date object. + + :param str attr: response string to be deserialized. + :rtype: Date + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + if re.search(r"[^\W\d_]", attr, re.I + re.U): + raise DeserializationError("Date must have only digits and -. Received: %s" % attr) + # This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception. + return isodate.parse_date(attr, defaultmonth=None, defaultday=None) + + @staticmethod + def deserialize_time(attr): + """Deserialize ISO-8601 formatted string into time object. + + :param str attr: response string to be deserialized. + :rtype: datetime.time + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + if re.search(r"[^\W\d_]", attr, re.I + re.U): + raise DeserializationError("Date must have only digits and -. Received: %s" % attr) + return isodate.parse_time(attr) + + @staticmethod + def deserialize_rfc(attr): + """Deserialize RFC-1123 formatted string into Datetime object. + + :param str attr: response string to be deserialized. + :rtype: Datetime + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + parsed_date = email.utils.parsedate_tz(attr) + date_obj = datetime.datetime( + *parsed_date[:6], tzinfo=_FixedOffset(datetime.timedelta(minutes=(parsed_date[9] or 0) / 60)) + ) + if not date_obj.tzinfo: + date_obj = date_obj.astimezone(tz=TZ_UTC) + except ValueError as err: + msg = "Cannot deserialize to rfc datetime object." + raise_with_traceback(DeserializationError, msg, err) + else: + return date_obj + + @staticmethod + def deserialize_iso(attr): + """Deserialize ISO-8601 formatted string into Datetime object. + + :param str attr: response string to be deserialized. + :rtype: Datetime + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + attr = attr.upper() + match = Deserializer.valid_date.match(attr) + if not match: + raise ValueError("Invalid datetime string: " + attr) + + check_decimal = attr.split(".") + if len(check_decimal) > 1: + decimal_str = "" + for digit in check_decimal[1]: + if digit.isdigit(): + decimal_str += digit + else: + break + if len(decimal_str) > 6: + attr = attr.replace(decimal_str, decimal_str[0:6]) + + date_obj = isodate.parse_datetime(attr) + test_utc = date_obj.utctimetuple() + if test_utc.tm_year > 9999 or test_utc.tm_year < 1: + raise OverflowError("Hit max or min date") + except (ValueError, OverflowError, AttributeError) as err: + msg = "Cannot deserialize datetime object." + raise_with_traceback(DeserializationError, msg, err) + else: + return date_obj + + @staticmethod + def deserialize_unix(attr): + """Serialize Datetime object into IntTime format. + This is represented as seconds. + + :param int attr: Object to be serialized. + :rtype: Datetime + :raises: DeserializationError if format invalid + """ + if isinstance(attr, ET.Element): + attr = int(attr.text) + try: + date_obj = datetime.datetime.fromtimestamp(attr, TZ_UTC) + except ValueError as err: + msg = "Cannot deserialize to unix datetime object." + raise_with_traceback(DeserializationError, msg, err) + else: + return date_obj diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_vendor.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_vendor.py new file mode 100644 index 0000000000000..2d0e02468b27c --- /dev/null +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_vendor.py @@ -0,0 +1,47 @@ +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft 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 abc import ABC +from typing import TYPE_CHECKING + +from azure.core.pipeline.transport import HttpRequest + +from ._configuration import AdvisorManagementClientConfiguration + +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from azure.core import PipelineClient + + from ._serialization import Deserializer, Serializer + + +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) + + +class MixinABC(ABC): + """DO NOT use this class. It is for internal typing use only.""" + + _client: "PipelineClient" + _config: AdvisorManagementClientConfiguration + _serialize: "Serializer" + _deserialize: "Deserializer" diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_version.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_version.py index b77ac9246082f..6dddc002d43d9 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_version.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "9.0.0" +VERSION = "9.0.0b1" diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/__init__.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/__init__.py index 7664234d2b8e7..ae9a4e0c88020 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/__init__.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/__init__.py @@ -7,4 +7,15 @@ # -------------------------------------------------------------------------- from ._advisor_management_client import AdvisorManagementClient -__all__ = ['AdvisorManagementClient'] + +try: + from ._patch import __all__ as _patch_all + from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +except ImportError: + _patch_all = [] +from ._patch import patch_sdk as _patch_sdk + +__all__ = ["AdvisorManagementClient"] +__all__.extend([p for p in _patch_all if p not in __all__]) + +_patch_sdk() diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_advisor_management_client.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_advisor_management_client.py index e3ec1109e996c..94c398c4fd0ef 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_advisor_management_client.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_advisor_management_client.py @@ -6,29 +6,37 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Optional, TYPE_CHECKING +from copy import deepcopy +from typing import Any, Awaitable, TYPE_CHECKING +from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.mgmt.core import AsyncARMPipelineClient -from msrest import Deserializer, Serializer + +from .. import models +from .._serialization import Deserializer, Serializer +from ._configuration import AdvisorManagementClientConfiguration +from .operations import ( + AdvisorManagementClientOperationsMixin, + ConfigurationsOperations, + Operations, + RecommendationMetadataOperations, + RecommendationsOperations, + SuppressionsOperations, +) if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials_async import AsyncTokenCredential -from ._configuration import AdvisorManagementClientConfiguration -from .operations import RecommendationMetadataOperations -from .operations import ConfigurationsOperations -from .operations import RecommendationsOperations -from .operations import Operations -from .operations import SuppressionsOperations -from .. import models - -class AdvisorManagementClient(object): +class AdvisorManagementClient( + AdvisorManagementClientOperationsMixin +): # pylint: disable=client-accepts-api-version-keyword """REST APIs for Azure Advisor. :ivar recommendation_metadata: RecommendationMetadataOperations operations - :vartype recommendation_metadata: azure.mgmt.advisor.aio.operations.RecommendationMetadataOperations + :vartype recommendation_metadata: + azure.mgmt.advisor.aio.operations.RecommendationMetadataOperations :ivar configurations: ConfigurationsOperations operations :vartype configurations: azure.mgmt.advisor.aio.operations.ConfigurationsOperations :ivar recommendations: RecommendationsOperations operations @@ -37,40 +45,62 @@ class AdvisorManagementClient(object): :vartype operations: azure.mgmt.advisor.aio.operations.Operations :ivar suppressions: SuppressionsOperations operations :vartype suppressions: azure.mgmt.advisor.aio.operations.SuppressionsOperations - :param credential: Credential needed for the client to connect to Azure. + :param credential: Credential needed for the client to connect to Azure. Required. :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: The Azure subscription ID. + :param subscription_id: The Azure subscription ID. Required. :type subscription_id: str - :param str base_url: Service URL + :param base_url: Service URL. Default value is "https://management.azure.com". + :type base_url: str + :keyword api_version: Api Version. Default value is "2022-09-01". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str """ def __init__( self, credential: "AsyncTokenCredential", subscription_id: str, - base_url: Optional[str] = None, + base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: - if not base_url: - base_url = 'https://management.azure.com' - self._config = AdvisorManagementClientConfiguration(credential, subscription_id, **kwargs) + self._config = AdvisorManagementClientConfiguration( + credential=credential, subscription_id=subscription_id, **kwargs + ) self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **kwargs) client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) - self._serialize.client_side_validation = False self._deserialize = Deserializer(client_models) - + self._serialize.client_side_validation = False self.recommendation_metadata = RecommendationMetadataOperations( - self._client, self._config, self._serialize, self._deserialize) - self.configurations = ConfigurationsOperations( - self._client, self._config, self._serialize, self._deserialize) - self.recommendations = RecommendationsOperations( - self._client, self._config, self._serialize, self._deserialize) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize) - self.suppressions = SuppressionsOperations( - self._client, self._config, self._serialize, self._deserialize) + self._client, self._config, self._serialize, self._deserialize + ) + self.configurations = ConfigurationsOperations(self._client, self._config, self._serialize, self._deserialize) + self.recommendations = RecommendationsOperations(self._client, self._config, self._serialize, self._deserialize) + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) + self.suppressions = SuppressionsOperations(self._client, self._config, self._serialize, self._deserialize) + + def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: + """Runs the network request through the client's chained policies. + + >>> from azure.core.rest import HttpRequest + >>> request = HttpRequest("GET", "https://www.example.org/") + + >>> response = await client._send_request(request) + + + For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request + + :param request: The network request you want to make. Required. + :type request: ~azure.core.rest.HttpRequest + :keyword bool stream: Whether the response payload will be streamed. Defaults to False. + :return: The response of your network call. Does not do error handling on your response. + :rtype: ~azure.core.rest.AsyncHttpResponse + """ + + request_copy = deepcopy(request) + request_copy.url = self._client.format_url(request_copy.url) + return self._client.send_request(request_copy, **kwargs) async def close(self) -> None: await self._client.close() diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_configuration.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_configuration.py index 435bf128a735a..b51d986ca8aea 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_configuration.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_configuration.py @@ -10,7 +10,7 @@ from azure.core.configuration import Configuration from azure.core.pipeline import policies -from azure.mgmt.core.policies import ARMHttpLoggingPolicy +from azure.mgmt.core.policies import ARMHttpLoggingPolicy, AsyncARMChallengeAuthenticationPolicy from .._version import VERSION @@ -19,49 +19,48 @@ from azure.core.credentials_async import AsyncTokenCredential -class AdvisorManagementClientConfiguration(Configuration): +class AdvisorManagementClientConfiguration(Configuration): # pylint: disable=too-many-instance-attributes """Configuration for AdvisorManagementClient. Note that all parameters used to create this instance are saved as instance attributes. - :param credential: Credential needed for the client to connect to Azure. + :param credential: Credential needed for the client to connect to Azure. Required. :type credential: ~azure.core.credentials_async.AsyncTokenCredential - :param subscription_id: The Azure subscription ID. + :param subscription_id: The Azure subscription ID. Required. :type subscription_id: str + :keyword api_version: Api Version. Default value is "2022-09-01". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str """ - def __init__( - self, - credential: "AsyncTokenCredential", - subscription_id: str, - **kwargs: Any - ) -> None: + def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: + super(AdvisorManagementClientConfiguration, self).__init__(**kwargs) + api_version = kwargs.pop("api_version", "2022-09-01") # type: str + if credential is None: raise ValueError("Parameter 'credential' must not be None.") if subscription_id is None: raise ValueError("Parameter 'subscription_id' must not be None.") - super(AdvisorManagementClientConfiguration, self).__init__(**kwargs) self.credential = credential self.subscription_id = subscription_id - self.api_version = "2020-01-01" - self.credential_scopes = kwargs.pop('credential_scopes', ['https://management.azure.com/.default']) - kwargs.setdefault('sdk_moniker', 'mgmt-advisor/{}'.format(VERSION)) + self.api_version = api_version + self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-advisor/{}".format(VERSION)) self._configure(**kwargs) - def _configure( - self, - **kwargs: Any - ) -> None: - self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) - self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) - self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) - self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) - self.http_logging_policy = kwargs.get('http_logging_policy') or ARMHttpLoggingPolicy(**kwargs) - self.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + def _configure(self, **kwargs: Any) -> None: + self.user_agent_policy = kwargs.get("user_agent_policy") or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get("headers_policy") or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs) + self.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) + self.authentication_policy = kwargs.get("authentication_policy") if self.credential and not self.authentication_policy: - self.authentication_policy = policies.AsyncBearerTokenCredentialPolicy(self.credential, *self.credential_scopes, **kwargs) + self.authentication_policy = AsyncARMChallengeAuthenticationPolicy( + self.credential, *self.credential_scopes, **kwargs + ) diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_patch.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_patch.py new file mode 100644 index 0000000000000..f7dd32510333d --- /dev/null +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_vendor.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_vendor.py new file mode 100644 index 0000000000000..5fa2ab3b4fdc9 --- /dev/null +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/_vendor.py @@ -0,0 +1,28 @@ +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft 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 abc import ABC +from typing import TYPE_CHECKING + +from azure.core.pipeline.transport import HttpRequest + +from ._configuration import AdvisorManagementClientConfiguration + +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from azure.core import AsyncPipelineClient + + from .._serialization import Deserializer, Serializer + + +class MixinABC(ABC): + """DO NOT use this class. It is for internal typing use only.""" + + _client: "AsyncPipelineClient" + _config: AdvisorManagementClientConfiguration + _serialize: "Serializer" + _deserialize: "Deserializer" diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/__init__.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/__init__.py index 090d96c72181f..5d68c12533564 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/__init__.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/__init__.py @@ -11,11 +11,19 @@ from ._recommendations_operations import RecommendationsOperations from ._operations import Operations from ._suppressions_operations import SuppressionsOperations +from ._advisor_management_client_operations import AdvisorManagementClientOperationsMixin + +from ._patch import __all__ as _patch_all +from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import patch_sdk as _patch_sdk __all__ = [ - 'RecommendationMetadataOperations', - 'ConfigurationsOperations', - 'RecommendationsOperations', - 'Operations', - 'SuppressionsOperations', + "RecommendationMetadataOperations", + "ConfigurationsOperations", + "RecommendationsOperations", + "Operations", + "SuppressionsOperations", + "AdvisorManagementClientOperationsMixin", ] +__all__.extend([p for p in _patch_all if p not in __all__]) +_patch_sdk() diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_advisor_management_client_operations.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_advisor_management_client_operations.py new file mode 100644 index 0000000000000..6742cfe62a97d --- /dev/null +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_advisor_management_client_operations.py @@ -0,0 +1,147 @@ +# pylint: disable=too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) +from azure.core.pipeline import PipelineResponse +from azure.core.pipeline.transport import AsyncHttpResponse +from azure.core.rest import HttpRequest +from azure.core.tracing.decorator_async import distributed_trace_async +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat + +from ... import models as _models +from ..._vendor import _convert_request +from ...operations._advisor_management_client_operations import build_predict_request +from .._vendor import MixinABC + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + + +class AdvisorManagementClientOperationsMixin(MixinABC): + @overload + async def predict( + self, prediction_request: _models.PredictionRequest, *, content_type: str = "application/json", **kwargs: Any + ) -> _models.PredictionResponse: + """Predicts a recommendation. + + Predicts a recommendation. + + :param prediction_request: Parameters for predict recommendation. Required. + :type prediction_request: ~azure.mgmt.advisor.models.PredictionRequest + :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: PredictionResponse or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.PredictionResponse + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def predict( + self, prediction_request: IO, *, content_type: str = "application/json", **kwargs: Any + ) -> _models.PredictionResponse: + """Predicts a recommendation. + + Predicts a recommendation. + + :param prediction_request: Parameters for predict recommendation. Required. + :type prediction_request: 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: PredictionResponse or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.PredictionResponse + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def predict( + self, prediction_request: Union[_models.PredictionRequest, IO], **kwargs: Any + ) -> _models.PredictionResponse: + """Predicts a recommendation. + + Predicts a recommendation. + + :param prediction_request: Parameters for predict recommendation. Is either a model type or a + IO type. Required. + :type prediction_request: ~azure.mgmt.advisor.models.PredictionRequest 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: PredictionResponse or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.PredictionResponse + :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 = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PredictionResponse] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(prediction_request, (IO, bytes)): + _content = prediction_request + else: + _json = self._serialize.body(prediction_request, "PredictionRequest") + + request = build_predict_request( + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.predict.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + + response = 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.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("PredictionResponse", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + predict.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/predict"} # type: ignore diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_configurations_operations.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_configurations_operations.py index 67e44455c615b..fdb873ce2fad8 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_configurations_operations.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_configurations_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -5,89 +6,111 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Generic, Optional, TypeVar, Union -import warnings +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +from urllib.parse import parse_qs, urljoin, urlparse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest +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 - -T = TypeVar('T') +from ..._vendor import _convert_request +from ...operations._configurations_operations import ( + build_create_in_resource_group_request, + build_create_in_subscription_request, + build_list_by_resource_group_request, + build_list_by_subscription_request, +) +from .._vendor import MixinABC + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] -class ConfigurationsOperations: - """ConfigurationsOperations async operations. - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. +class ConfigurationsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.mgmt.advisor.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + Instead, you should access the following operations through + :class:`~azure.mgmt.advisor.aio.AdvisorManagementClient`'s + :attr:`configurations` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer) -> None: - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config + 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") - def list_by_subscription( - self, - **kwargs - ) -> AsyncIterable["_models.ConfigurationListResult"]: + @distributed_trace + def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.ConfigData"]: """Retrieve Azure Advisor configurations. Retrieve Azure Advisor configurations and also retrieve configurations of contained resource groups. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ConfigurationListResult or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.advisor.models.ConfigurationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ConfigData or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.advisor.models.ConfigData] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ConfigurationListResult"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConfigurationListResult] + error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list_by_subscription.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + + 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) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] - request = self._client.get(url, query_parameters, header_parameters) + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + request.method = "GET" return request async def extract_data(pipeline_response): - deserialized = self._deserialize('ConfigurationListResult', pipeline_response) + deserialized = self._deserialize("ConfigurationListResult", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -96,137 +119,215 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: - error = self._deserialize(_models.ArmErrorResponse, response) map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, 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.Advisor/configurations'} # type: ignore + return AsyncItemPaged(get_next, extract_data) + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/configurations"} # type: ignore + + @overload async def create_in_subscription( self, configuration_name: Union[str, "_models.ConfigurationName"], - config_contract: "_models.ConfigData", - **kwargs - ) -> "_models.ConfigData": + config_contract: _models.ConfigData, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.ConfigData: """Create/Overwrite Azure Advisor configuration. Create/Overwrite Azure Advisor configuration and also delete all configurations of contained resource groups. - :param configuration_name: Advisor configuration name. Value must be 'default'. + :param configuration_name: Advisor configuration name. Value must be 'default'. "default" + Required. :type configuration_name: str or ~azure.mgmt.advisor.models.ConfigurationName - :param config_contract: The Azure Advisor configuration data structure. + :param config_contract: The Azure Advisor configuration data structure. Required. :type config_contract: ~azure.mgmt.advisor.models.ConfigData + :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: ConfigData or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.ConfigData + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_in_subscription( + self, + configuration_name: Union[str, "_models.ConfigurationName"], + config_contract: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.ConfigData: + """Create/Overwrite Azure Advisor configuration. + + Create/Overwrite Azure Advisor configuration and also delete all configurations of contained + resource groups. + + :param configuration_name: Advisor configuration name. Value must be 'default'. "default" + Required. + :type configuration_name: str or ~azure.mgmt.advisor.models.ConfigurationName + :param config_contract: The Azure Advisor configuration data structure. Required. + :type config_contract: 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: ConfigData or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.ConfigData + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_in_subscription( + self, + configuration_name: Union[str, "_models.ConfigurationName"], + config_contract: Union[_models.ConfigData, IO], + **kwargs: Any + ) -> _models.ConfigData: + """Create/Overwrite Azure Advisor configuration. + + Create/Overwrite Azure Advisor configuration and also delete all configurations of contained + resource groups. + + :param configuration_name: Advisor configuration name. Value must be 'default'. "default" + Required. + :type configuration_name: str or ~azure.mgmt.advisor.models.ConfigurationName + :param config_contract: The Azure Advisor configuration data structure. Is either a model type + or a IO type. Required. + :type config_contract: ~azure.mgmt.advisor.models.ConfigData 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: ConfigData, or the result of cls(response) + :return: ConfigData or the result of cls(response) :rtype: ~azure.mgmt.advisor.models.ConfigData - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ConfigData"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" - - # Construct URL - url = self.create_in_subscription.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - 'configurationName': self._serialize.url("configuration_name", configuration_name, 'str'), + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(config_contract, 'ConfigData') - body_content_kwargs['content'] = body_content - request = self._client.put(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConfigData] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(config_contract, (IO, bytes)): + _content = config_contract + else: + _json = self._serialize.body(config_contract, "ConfigData") + + request = build_create_in_subscription_request( + configuration_name=configuration_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.create_in_subscription.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = 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(_models.ArmErrorResponse, response) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('ConfigData', pipeline_response) + deserialized = self._deserialize("ConfigData", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_in_subscription.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/configurations/{configurationName}'} # type: ignore - def list_by_resource_group( - self, - resource_group: str, - **kwargs - ) -> AsyncIterable["_models.ConfigurationListResult"]: + create_in_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/configurations/{configurationName}"} # type: ignore + + @distributed_trace + def list_by_resource_group(self, resource_group: str, **kwargs: Any) -> AsyncIterable["_models.ConfigData"]: """Retrieve Azure Advisor configurations. Retrieve Azure Advisor configurations. - :param resource_group: The name of the Azure resource group. + :param resource_group: The name of the Azure resource group. Required. :type resource_group: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ConfigurationListResult or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.advisor.models.ConfigurationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ConfigData or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.advisor.models.ConfigData] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ConfigurationListResult"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConfigurationListResult] + error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list_by_resource_group.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - 'resourceGroup': self._serialize.url("resource_group", resource_group, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + + request = build_list_by_resource_group_request( + resource_group=resource_group, + 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) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] - request = self._client.get(url, query_parameters, header_parameters) + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + request.method = "GET" return request async def extract_data(pipeline_response): - deserialized = self._deserialize('ConfigurationListResult', pipeline_response) + deserialized = self._deserialize("ConfigurationListResult", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -235,86 +336,164 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: - error = self._deserialize(_models.ArmErrorResponse, response) map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, 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/{resourceGroup}/providers/Microsoft.Advisor/configurations'} # type: ignore + return AsyncItemPaged(get_next, extract_data) + + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Advisor/configurations"} # type: ignore + @overload async def create_in_resource_group( self, configuration_name: Union[str, "_models.ConfigurationName"], resource_group: str, - config_contract: "_models.ConfigData", - **kwargs - ) -> "_models.ConfigData": + config_contract: _models.ConfigData, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.ConfigData: """Create/Overwrite Azure Advisor configuration. Create/Overwrite Azure Advisor configuration. - :param configuration_name: Advisor configuration name. Value must be 'default'. + :param configuration_name: Advisor configuration name. Value must be 'default'. "default" + Required. :type configuration_name: str or ~azure.mgmt.advisor.models.ConfigurationName - :param resource_group: The name of the Azure resource group. + :param resource_group: The name of the Azure resource group. Required. :type resource_group: str - :param config_contract: The Azure Advisor configuration data structure. + :param config_contract: The Azure Advisor configuration data structure. Required. :type config_contract: ~azure.mgmt.advisor.models.ConfigData + :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: ConfigData, or the result of cls(response) + :return: ConfigData or the result of cls(response) :rtype: ~azure.mgmt.advisor.models.ConfigData - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_in_resource_group( + self, + configuration_name: Union[str, "_models.ConfigurationName"], + resource_group: str, + config_contract: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.ConfigData: + """Create/Overwrite Azure Advisor configuration. + + Create/Overwrite Azure Advisor configuration. + + :param configuration_name: Advisor configuration name. Value must be 'default'. "default" + Required. + :type configuration_name: str or ~azure.mgmt.advisor.models.ConfigurationName + :param resource_group: The name of the Azure resource group. Required. + :type resource_group: str + :param config_contract: The Azure Advisor configuration data structure. Required. + :type config_contract: 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: ConfigData or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.ConfigData + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_in_resource_group( + self, + configuration_name: Union[str, "_models.ConfigurationName"], + resource_group: str, + config_contract: Union[_models.ConfigData, IO], + **kwargs: Any + ) -> _models.ConfigData: + """Create/Overwrite Azure Advisor configuration. + + Create/Overwrite Azure Advisor configuration. + + :param configuration_name: Advisor configuration name. Value must be 'default'. "default" + Required. + :type configuration_name: str or ~azure.mgmt.advisor.models.ConfigurationName + :param resource_group: The name of the Azure resource group. Required. + :type resource_group: str + :param config_contract: The Azure Advisor configuration data structure. Is either a model type + or a IO type. Required. + :type config_contract: ~azure.mgmt.advisor.models.ConfigData 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: ConfigData or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.ConfigData + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ConfigData"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" - - # Construct URL - url = self.create_in_resource_group.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - 'configurationName': self._serialize.url("configuration_name", configuration_name, 'str'), - 'resourceGroup': self._serialize.url("resource_group", resource_group, 'str'), + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(config_contract, 'ConfigData') - body_content_kwargs['content'] = body_content - request = self._client.put(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConfigData] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(config_contract, (IO, bytes)): + _content = config_contract + else: + _json = self._serialize.body(config_contract, "ConfigData") + + request = build_create_in_resource_group_request( + configuration_name=configuration_name, + resource_group=resource_group, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.create_in_resource_group.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = 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(_models.ArmErrorResponse, response) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('ConfigData', pipeline_response) + deserialized = self._deserialize("ConfigData", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_in_resource_group.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Advisor/configurations/{configurationName}'} # type: ignore + + create_in_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Advisor/configurations/{configurationName}"} # type: ignore diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_operations.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_operations.py index 3fe50c593ca2e..bc1d84037e689 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_operations.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -5,82 +6,101 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Generic, Optional, TypeVar -import warnings +from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from urllib.parse import parse_qs, urljoin, urlparse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest +from azure.core.pipeline.transport import AsyncHttpResponse +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 ..._vendor import _convert_request +from ...operations._operations import build_list_request +from .._vendor import MixinABC -T = TypeVar('T') +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] -class Operations: - """Operations async operations. - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. +class Operations: + """ + .. warning:: + **DO NOT** instantiate this class directly. - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.mgmt.advisor.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + Instead, you should access the following operations through + :class:`~azure.mgmt.advisor.aio.AdvisorManagementClient`'s + :attr:`operations` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer) -> None: - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config + 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") - def list( - self, - **kwargs - ) -> AsyncIterable["_models.OperationEntityListResult"]: + @distributed_trace + def list(self, **kwargs: Any) -> AsyncIterable["_models.OperationEntity"]: """Lists all the available Advisor REST API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationEntityListResult or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.advisor.models.OperationEntityListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either OperationEntity or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.advisor.models.OperationEntity] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.OperationEntityListResult"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationEntityListResult] + error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list.metadata['url'] # type: ignore - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - request = self._client.get(url, query_parameters, header_parameters) + 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) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] - request = self._client.get(url, query_parameters, header_parameters) + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + request.method = "GET" return request async def extract_data(pipeline_response): - deserialized = self._deserialize('OperationEntityListResult', pipeline_response) + deserialized = self._deserialize("OperationEntityListResult", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -89,16 +109,18 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, 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.Advisor/operations'} # type: ignore + return AsyncItemPaged(get_next, extract_data) + + list.metadata = {"url": "/providers/Microsoft.Advisor/operations"} # type: ignore diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_patch.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_patch.py new file mode 100644 index 0000000000000..f7dd32510333d --- /dev/null +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_recommendation_metadata_operations.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_recommendation_metadata_operations.py index d27f76a07f7c9..5bf4de9c0722d 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_recommendation_metadata_operations.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_recommendation_metadata_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -5,143 +6,165 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Generic, Optional, TypeVar, Union -import warnings +from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from urllib.parse import parse_qs, urljoin, urlparse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest +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._recommendation_metadata_operations import build_get_request, build_list_request +from .._vendor import MixinABC -T = TypeVar('T') +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] -class RecommendationMetadataOperations: - """RecommendationMetadataOperations async operations. - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. +class RecommendationMetadataOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.mgmt.advisor.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + Instead, you should access the following operations through + :class:`~azure.mgmt.advisor.aio.AdvisorManagementClient`'s + :attr:`recommendation_metadata` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer) -> None: - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config - - async def get( - self, - name: str, - **kwargs - ) -> Union["_models.MetadataEntity", "_models.ARMErrorResponseBody"]: + 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_async + async def get(self, name: str, **kwargs: Any) -> _models.MetadataEntity: """Gets the metadata entity. Gets the metadata entity. - :param name: Name of metadata entity. + :param name: Name of metadata entity. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MetadataEntity or ARMErrorResponseBody, or the result of cls(response) - :rtype: ~azure.mgmt.advisor.models.MetadataEntity or ~azure.mgmt.advisor.models.ARMErrorResponseBody - :raises: ~azure.core.exceptions.HttpResponseError + :return: MetadataEntity or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.MetadataEntity + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[Union["_models.MetadataEntity", "_models.ARMErrorResponseBody"]] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" - - # Construct URL - url = self.get.metadata['url'] # type: ignore - path_format_arguments = { - 'name': self._serialize.url("name", name, 'str'), + 401: ClientAuthenticationError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + 404: lambda response: ResourceNotFoundError( + response=response, + model=self._deserialize(_models.ARMErrorResponseBody, response), + error_format=ARMErrorFormat, + ), } - url = self._client.format_url(url, **path_format_arguments) + error_map.update(kwargs.pop("error_map", {}) or {}) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MetadataEntity] + + request = build_get_request( + name=name, + 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) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.get(url, query_parameters, header_parameters) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response - if response.status_code not in [200, 404]: + if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize('MetadataEntity', pipeline_response) - - if response.status_code == 404: - deserialized = self._deserialize('ARMErrorResponseBody', pipeline_response) + deserialized = self._deserialize("MetadataEntity", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': '/providers/Microsoft.Advisor/metadata/{name}'} # type: ignore - def list( - self, - **kwargs - ) -> AsyncIterable["_models.MetadataEntityListResult"]: + get.metadata = {"url": "/providers/Microsoft.Advisor/metadata/{name}"} # type: ignore + + @distributed_trace + def list(self, **kwargs: Any) -> AsyncIterable["_models.MetadataEntity"]: """Gets the list of metadata entities. Gets the list of metadata entities. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either MetadataEntityListResult or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.advisor.models.MetadataEntityListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either MetadataEntity or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.advisor.models.MetadataEntity] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.MetadataEntityListResult"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MetadataEntityListResult] + error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list.metadata['url'] # type: ignore - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - request = self._client.get(url, query_parameters, header_parameters) + 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) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] - request = self._client.get(url, query_parameters, header_parameters) + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + request.method = "GET" return request async def extract_data(pipeline_response): - deserialized = self._deserialize('MetadataEntityListResult', pipeline_response) + deserialized = self._deserialize("MetadataEntityListResult", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -150,16 +173,18 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, 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.Advisor/metadata'} # type: ignore + return AsyncItemPaged(get_next, extract_data) + + list.metadata = {"url": "/providers/Microsoft.Advisor/metadata"} # type: ignore diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_recommendations_operations.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_recommendations_operations.py index 2f99233dc3f71..fb56d3a24d045 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_recommendations_operations.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_recommendations_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -5,209 +6,239 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Generic, Optional, TypeVar -import warnings +from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from urllib.parse import parse_qs, urljoin, urlparse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest +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 - -T = TypeVar('T') +from ..._vendor import _convert_request +from ...operations._recommendations_operations import ( + build_generate_request, + build_get_generate_status_request, + build_get_request, + build_list_request, +) +from .._vendor import MixinABC + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] -class RecommendationsOperations: - """RecommendationsOperations async operations. - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. +class RecommendationsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.mgmt.advisor.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + Instead, you should access the following operations through + :class:`~azure.mgmt.advisor.aio.AdvisorManagementClient`'s + :attr:`recommendations` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer) -> None: - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config + 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") - async def generate( - self, - **kwargs - ) -> None: + @distributed_trace_async + async def generate(self, **kwargs: Any) -> None: # pylint: disable=inconsistent-return-statements """Initiates the recommendation generation or computation process for a subscription. This operation is asynchronous. The generated recommendations are stored in a cache in the Advisor service. :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" + error_map.update(kwargs.pop("error_map", {}) or {}) - # Construct URL - url = self.generate.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + request = build_generate_request( + subscription_id=self._config.subscription_id, + api_version=api_version, + template_url=self.generate.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore - # Construct headers - header_parameters = {} # type: Dict[str, Any] + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.post(url, query_parameters, header_parameters) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - response_headers['Retry-After']=self._deserialize('str', response.headers.get('Retry-After')) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("str", response.headers.get("Retry-After")) if cls: return cls(pipeline_response, None, response_headers) - generate.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/generateRecommendations'} # type: ignore + generate.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/generateRecommendations"} # type: ignore - async def get_generate_status( - self, - operation_id: str, - **kwargs + @distributed_trace_async + async def get_generate_status( # pylint: disable=inconsistent-return-statements + self, operation_id: str, **kwargs: Any ) -> None: """Retrieves the status of the recommendation computation or generation process. Invoke this API after calling the generation recommendation. The URI of this API is returned in the Location field of the response header. :param operation_id: The operation ID, which can be found from the Location field in the - generate recommendation response header. + generate recommendation response header. Required. :type operation_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - - # Construct URL - url = self.get_generate_status.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - 'operationId': self._serialize.url("operation_id", operation_id, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - # Construct headers - header_parameters = {} # type: Dict[str, Any] + request = build_get_generate_status_request( + operation_id=operation_id, + subscription_id=self._config.subscription_id, + api_version=api_version, + template_url=self.get_generate_status.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.get(url, query_parameters, header_parameters) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [202, 204]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - get_generate_status.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/generateRecommendations/{operationId}'} # type: ignore + get_generate_status.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/generateRecommendations/{operationId}"} # type: ignore + @distributed_trace def list( - self, - filter: Optional[str] = None, - top: Optional[int] = None, - skip_token: Optional[str] = None, - **kwargs - ) -> AsyncIterable["_models.ResourceRecommendationBaseListResult"]: + self, filter: Optional[str] = None, top: Optional[int] = None, skip_token: Optional[str] = None, **kwargs: Any + ) -> AsyncIterable["_models.ResourceRecommendationBase"]: """Obtains cached recommendations for a subscription. The recommendations are generated or computed by invoking generateRecommendations. :param filter: The filter to apply to the recommendations.:code:`
`Filter can be applied to properties ['ResourceId', 'ResourceGroup', 'RecommendationTypeGuid', '\ `Category <#category>`_\ '] with operators ['eq', 'and', 'or'].:code:`
`Example::code:`
`- - $filter=Category eq 'Cost' and ResourceGroup eq 'MyResourceGroup'. + $filter=Category eq 'Cost' and ResourceGroup eq 'MyResourceGroup'. Default value is None. :type filter: str :param top: The number of recommendations per page if a paged version of this API is being - used. + used. Default value is None. :type top: int - :param skip_token: The page-continuation token to use with a paged version of this API. + :param skip_token: The page-continuation token to use with a paged version of this API. Default + value is None. :type skip_token: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceRecommendationBaseListResult or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.advisor.models.ResourceRecommendationBaseListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ResourceRecommendationBase or the result of + cls(response) + :rtype: + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.advisor.models.ResourceRecommendationBase] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ResourceRecommendationBaseListResult"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceRecommendationBaseListResult] + error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - if filter is not None: - query_parameters['$filter'] = self._serialize.query("filter", filter, 'str') - if top is not None: - query_parameters['$top'] = self._serialize.query("top", top, 'int') - if skip_token is not None: - query_parameters['$skipToken'] = self._serialize.query("skip_token", skip_token, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + + request = build_list_request( + subscription_id=self._config.subscription_id, + filter=filter, + top=top, + skip_token=skip_token, + 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) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] - request = self._client.get(url, query_parameters, header_parameters) + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + request.method = "GET" return request async def extract_data(pipeline_response): - deserialized = self._deserialize('ResourceRecommendationBaseListResult', pipeline_response) + deserialized = self._deserialize("ResourceRecommendationBaseListResult", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -216,74 +247,77 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) return pipeline_response - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/recommendations'} # type: ignore - - async def get( - self, - resource_uri: str, - recommendation_id: str, - **kwargs - ) -> "_models.ResourceRecommendationBase": + return AsyncItemPaged(get_next, extract_data) + + list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/recommendations"} # type: ignore + + @distributed_trace_async + async def get(self, resource_uri: str, recommendation_id: str, **kwargs: Any) -> _models.ResourceRecommendationBase: """Obtains details of a cached recommendation. :param resource_uri: The fully qualified Azure Resource Manager identifier of the resource to - which the recommendation applies. + which the recommendation applies. Required. :type resource_uri: str - :param recommendation_id: The recommendation ID. + :param recommendation_id: The recommendation ID. Required. :type recommendation_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ResourceRecommendationBase, or the result of cls(response) + :return: ResourceRecommendationBase or the result of cls(response) :rtype: ~azure.mgmt.advisor.models.ResourceRecommendationBase - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ResourceRecommendationBase"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" - - # Construct URL - url = self.get.metadata['url'] # type: ignore - path_format_arguments = { - 'resourceUri': self._serialize.url("resource_uri", resource_uri, 'str'), - 'recommendationId': self._serialize.url("recommendation_id", recommendation_id, 'str'), + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - url = self._client.format_url(url, **path_format_arguments) + error_map.update(kwargs.pop("error_map", {}) or {}) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceRecommendationBase] + + request = build_get_request( + resource_uri=resource_uri, + recommendation_id=recommendation_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) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.get(url, query_parameters, header_parameters) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('ResourceRecommendationBase', pipeline_response) + deserialized = self._deserialize("ResourceRecommendationBase", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': '/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}'} # type: ignore + + get.metadata = {"url": "/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}"} # type: ignore diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_suppressions_operations.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_suppressions_operations.py index 99073a34d7638..73459a63f994b 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_suppressions_operations.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/aio/operations/_suppressions_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -5,298 +6,409 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Generic, Optional, TypeVar, Union -import warnings +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +from urllib.parse import parse_qs, urljoin, urlparse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest +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 - -T = TypeVar('T') +from ..._vendor import _convert_request +from ...operations._suppressions_operations import ( + build_create_request, + build_delete_request, + build_get_request, + build_list_request, +) +from .._vendor import MixinABC + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] -class SuppressionsOperations: - """SuppressionsOperations async operations. - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. +class SuppressionsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.mgmt.advisor.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + Instead, you should access the following operations through + :class:`~azure.mgmt.advisor.aio.AdvisorManagementClient`'s + :attr:`suppressions` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer) -> None: - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config + 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_async async def get( - self, - resource_uri: str, - recommendation_id: str, - name: str, - **kwargs - ) -> Union["_models.SuppressionContract", "_models.ArmErrorResponse"]: + self, resource_uri: str, recommendation_id: str, name: str, **kwargs: Any + ) -> _models.SuppressionContract: """Obtains the details of a suppression. :param resource_uri: The fully qualified Azure Resource Manager identifier of the resource to - which the recommendation applies. + which the recommendation applies. Required. :type resource_uri: str - :param recommendation_id: The recommendation ID. + :param recommendation_id: The recommendation ID. Required. :type recommendation_id: str - :param name: The name of the suppression. + :param name: The name of the suppression. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SuppressionContract or ArmErrorResponse, or the result of cls(response) - :rtype: ~azure.mgmt.advisor.models.SuppressionContract or ~azure.mgmt.advisor.models.ArmErrorResponse - :raises: ~azure.core.exceptions.HttpResponseError + :return: SuppressionContract or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.SuppressionContract + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[Union["_models.SuppressionContract", "_models.ArmErrorResponse"]] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" - - # Construct URL - url = self.get.metadata['url'] # type: ignore - path_format_arguments = { - 'resourceUri': self._serialize.url("resource_uri", resource_uri, 'str'), - 'recommendationId': self._serialize.url("recommendation_id", recommendation_id, 'str'), - 'name': self._serialize.url("name", name, 'str'), + 401: ClientAuthenticationError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + 404: lambda response: ResourceNotFoundError( + response=response, + model=self._deserialize(_models.ArmErrorResponse, response), + error_format=ARMErrorFormat, + ), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SuppressionContract] + + request = build_get_request( + resource_uri=resource_uri, + recommendation_id=recommendation_id, + name=name, + 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) # type: ignore - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.get(url, query_parameters, header_parameters) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response - if response.status_code not in [200, 404]: + if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize('SuppressionContract', pipeline_response) - - if response.status_code == 404: - deserialized = self._deserialize('ArmErrorResponse', pipeline_response) + deserialized = self._deserialize("SuppressionContract", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': '/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}/suppressions/{name}'} # type: ignore + get.metadata = {"url": "/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}/suppressions/{name}"} # type: ignore + + @overload async def create( self, resource_uri: str, recommendation_id: str, name: str, - suppression_contract: "_models.SuppressionContract", - **kwargs - ) -> Union["_models.SuppressionContract", "_models.ArmErrorResponse"]: + suppression_contract: _models.SuppressionContract, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SuppressionContract: """Enables the snoozed or dismissed attribute of a recommendation. The snoozed or dismissed attribute is referred to as a suppression. Use this API to create or update the snoozed or dismissed status of a recommendation. :param resource_uri: The fully qualified Azure Resource Manager identifier of the resource to - which the recommendation applies. + which the recommendation applies. Required. :type resource_uri: str - :param recommendation_id: The recommendation ID. + :param recommendation_id: The recommendation ID. Required. :type recommendation_id: str - :param name: The name of the suppression. + :param name: The name of the suppression. Required. :type name: str :param suppression_contract: The snoozed or dismissed attribute; for example, the snooze - duration. + duration. Required. :type suppression_contract: ~azure.mgmt.advisor.models.SuppressionContract + :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: SuppressionContract or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.SuppressionContract + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create( + self, + resource_uri: str, + recommendation_id: str, + name: str, + suppression_contract: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SuppressionContract: + """Enables the snoozed or dismissed attribute of a recommendation. The snoozed or dismissed + attribute is referred to as a suppression. Use this API to create or update the snoozed or + dismissed status of a recommendation. + + :param resource_uri: The fully qualified Azure Resource Manager identifier of the resource to + which the recommendation applies. Required. + :type resource_uri: str + :param recommendation_id: The recommendation ID. Required. + :type recommendation_id: str + :param name: The name of the suppression. Required. + :type name: str + :param suppression_contract: The snoozed or dismissed attribute; for example, the snooze + duration. Required. + :type suppression_contract: 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: SuppressionContract or ArmErrorResponse, or the result of cls(response) - :rtype: ~azure.mgmt.advisor.models.SuppressionContract or ~azure.mgmt.advisor.models.ArmErrorResponse - :raises: ~azure.core.exceptions.HttpResponseError + :return: SuppressionContract or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.SuppressionContract + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create( + self, + resource_uri: str, + recommendation_id: str, + name: str, + suppression_contract: Union[_models.SuppressionContract, IO], + **kwargs: Any + ) -> _models.SuppressionContract: + """Enables the snoozed or dismissed attribute of a recommendation. The snoozed or dismissed + attribute is referred to as a suppression. Use this API to create or update the snoozed or + dismissed status of a recommendation. + + :param resource_uri: The fully qualified Azure Resource Manager identifier of the resource to + which the recommendation applies. Required. + :type resource_uri: str + :param recommendation_id: The recommendation ID. Required. + :type recommendation_id: str + :param name: The name of the suppression. Required. + :type name: str + :param suppression_contract: The snoozed or dismissed attribute; for example, the snooze + duration. Is either a model type or a IO type. Required. + :type suppression_contract: ~azure.mgmt.advisor.models.SuppressionContract 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: SuppressionContract or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.SuppressionContract + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[Union["_models.SuppressionContract", "_models.ArmErrorResponse"]] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + 404: lambda response: ResourceNotFoundError( + response=response, + model=self._deserialize(_models.ArmErrorResponse, response), + error_format=ARMErrorFormat, + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" - - # Construct URL - url = self.create.metadata['url'] # type: ignore - path_format_arguments = { - 'resourceUri': self._serialize.url("resource_uri", resource_uri, 'str'), - 'recommendationId': self._serialize.url("recommendation_id", recommendation_id, 'str'), - 'name': self._serialize.url("name", name, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(suppression_contract, 'SuppressionContract') - body_content_kwargs['content'] = body_content - request = self._client.put(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.SuppressionContract] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(suppression_contract, (IO, bytes)): + _content = suppression_contract + else: + _json = self._serialize.body(suppression_contract, "SuppressionContract") + + request = build_create_request( + resource_uri=resource_uri, + recommendation_id=recommendation_id, + name=name, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.create.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response - if response.status_code not in [200, 404]: + if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize('SuppressionContract', pipeline_response) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - if response.status_code == 404: - deserialized = self._deserialize('ArmErrorResponse', pipeline_response) + deserialized = self._deserialize("SuppressionContract", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': '/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}/suppressions/{name}'} # type: ignore - async def delete( - self, - resource_uri: str, - recommendation_id: str, - name: str, - **kwargs + create.metadata = {"url": "/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}/suppressions/{name}"} # type: ignore + + @distributed_trace_async + async def delete( # pylint: disable=inconsistent-return-statements + self, resource_uri: str, recommendation_id: str, name: str, **kwargs: Any ) -> None: """Enables the activation of a snoozed or dismissed recommendation. The snoozed or dismissed attribute of a recommendation is referred to as a suppression. :param resource_uri: The fully qualified Azure Resource Manager identifier of the resource to - which the recommendation applies. + which the recommendation applies. Required. :type resource_uri: str - :param recommendation_id: The recommendation ID. + :param recommendation_id: The recommendation ID. Required. :type recommendation_id: str - :param name: The name of the suppression. + :param name: The name of the suppression. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - - # Construct URL - url = self.delete.metadata['url'] # type: ignore - path_format_arguments = { - 'resourceUri': self._serialize.url("resource_uri", resource_uri, 'str'), - 'recommendationId': self._serialize.url("recommendation_id", recommendation_id, 'str'), - 'name': self._serialize.url("name", name, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + + request = build_delete_request( + resource_uri=resource_uri, + recommendation_id=recommendation_id, + name=name, + 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) # type: ignore - # Construct headers - header_parameters = {} # type: Dict[str, Any] + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.delete(url, query_parameters, header_parameters) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': '/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}/suppressions/{name}'} # type: ignore + delete.metadata = {"url": "/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}/suppressions/{name}"} # type: ignore + @distributed_trace def list( - self, - top: Optional[int] = None, - skip_token: Optional[str] = None, - **kwargs - ) -> AsyncIterable["_models.SuppressionContractListResult"]: + self, top: Optional[int] = None, skip_token: Optional[str] = None, **kwargs: Any + ) -> AsyncIterable["_models.SuppressionContract"]: """Retrieves the list of snoozed or dismissed suppressions for a subscription. The snoozed or dismissed attribute of a recommendation is referred to as a suppression. :param top: The number of suppressions per page if a paged version of this API is being used. + Default value is None. :type top: int - :param skip_token: The page-continuation token to use with a paged version of this API. + :param skip_token: The page-continuation token to use with a paged version of this API. Default + value is None. :type skip_token: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SuppressionContractListResult or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.advisor.models.SuppressionContractListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either SuppressionContract or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.advisor.models.SuppressionContract] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.SuppressionContractListResult"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SuppressionContractListResult] + error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - if top is not None: - query_parameters['$top'] = self._serialize.query("top", top, 'int') - if skip_token is not None: - query_parameters['$skipToken'] = self._serialize.query("skip_token", skip_token, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + + request = build_list_request( + subscription_id=self._config.subscription_id, + top=top, + skip_token=skip_token, + 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) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] - request = self._client.get(url, query_parameters, header_parameters) + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + request.method = "GET" return request async def extract_data(pipeline_response): - deserialized = self._deserialize('SuppressionContractListResult', pipeline_response) + deserialized = self._deserialize("SuppressionContractListResult", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -305,16 +417,18 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) return pipeline_response - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/suppressions'} # type: ignore + return AsyncItemPaged(get_next, extract_data) + + list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/suppressions"} # type: ignore diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/__init__.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/__init__.py index b5a374bf6f819..83f136ba929b0 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/__init__.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/__init__.py @@ -6,79 +6,70 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -try: - from ._models_py3 import ARMErrorResponseBody - from ._models_py3 import ArmErrorResponse - from ._models_py3 import ConfigData - from ._models_py3 import ConfigurationListResult - from ._models_py3 import DigestConfig - from ._models_py3 import MetadataEntity - from ._models_py3 import MetadataEntityListResult - from ._models_py3 import MetadataSupportedValueDetail - from ._models_py3 import OperationDisplayInfo - from ._models_py3 import OperationEntity - from ._models_py3 import OperationEntityListResult - from ._models_py3 import Resource - from ._models_py3 import ResourceMetadata - from ._models_py3 import ResourceRecommendationBase - from ._models_py3 import ResourceRecommendationBaseListResult - from ._models_py3 import ShortDescription - from ._models_py3 import SuppressionContract - from ._models_py3 import SuppressionContractListResult -except (SyntaxError, ImportError): - from ._models import ARMErrorResponseBody # type: ignore - from ._models import ArmErrorResponse # type: ignore - from ._models import ConfigData # type: ignore - from ._models import ConfigurationListResult # type: ignore - from ._models import DigestConfig # type: ignore - from ._models import MetadataEntity # type: ignore - from ._models import MetadataEntityListResult # type: ignore - from ._models import MetadataSupportedValueDetail # type: ignore - from ._models import OperationDisplayInfo # type: ignore - from ._models import OperationEntity # type: ignore - from ._models import OperationEntityListResult # type: ignore - from ._models import Resource # type: ignore - from ._models import ResourceMetadata # type: ignore - from ._models import ResourceRecommendationBase # type: ignore - from ._models import ResourceRecommendationBaseListResult # type: ignore - from ._models import ShortDescription # type: ignore - from ._models import SuppressionContract # type: ignore - from ._models import SuppressionContractListResult # type: ignore +from ._models_py3 import ARMErrorResponseBody +from ._models_py3 import ArmErrorResponse +from ._models_py3 import ConfigData +from ._models_py3 import ConfigurationListResult +from ._models_py3 import DigestConfig +from ._models_py3 import MetadataEntity +from ._models_py3 import MetadataEntityListResult +from ._models_py3 import MetadataSupportedValueDetail +from ._models_py3 import OperationDisplayInfo +from ._models_py3 import OperationEntity +from ._models_py3 import OperationEntityListResult +from ._models_py3 import PredictionRequest +from ._models_py3 import PredictionResponse +from ._models_py3 import Resource +from ._models_py3 import ResourceMetadata +from ._models_py3 import ResourceRecommendationBase +from ._models_py3 import ResourceRecommendationBaseListResult +from ._models_py3 import ShortDescription +from ._models_py3 import SuppressionContract +from ._models_py3 import SuppressionContractListResult -from ._advisor_management_client_enums import ( - Category, - ConfigurationName, - CpuThreshold, - DigestConfigState, - Impact, - Risk, - Scenario, -) +from ._advisor_management_client_enums import Category +from ._advisor_management_client_enums import ConfigurationName +from ._advisor_management_client_enums import CpuThreshold +from ._advisor_management_client_enums import DigestConfigState +from ._advisor_management_client_enums import Duration +from ._advisor_management_client_enums import Impact +from ._advisor_management_client_enums import PredictionType +from ._advisor_management_client_enums import Risk +from ._advisor_management_client_enums import Scenario +from ._patch import __all__ as _patch_all +from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import patch_sdk as _patch_sdk __all__ = [ - 'ARMErrorResponseBody', - 'ArmErrorResponse', - 'ConfigData', - 'ConfigurationListResult', - 'DigestConfig', - 'MetadataEntity', - 'MetadataEntityListResult', - 'MetadataSupportedValueDetail', - 'OperationDisplayInfo', - 'OperationEntity', - 'OperationEntityListResult', - 'Resource', - 'ResourceMetadata', - 'ResourceRecommendationBase', - 'ResourceRecommendationBaseListResult', - 'ShortDescription', - 'SuppressionContract', - 'SuppressionContractListResult', - 'Category', - 'ConfigurationName', - 'CpuThreshold', - 'DigestConfigState', - 'Impact', - 'Risk', - 'Scenario', + "ARMErrorResponseBody", + "ArmErrorResponse", + "ConfigData", + "ConfigurationListResult", + "DigestConfig", + "MetadataEntity", + "MetadataEntityListResult", + "MetadataSupportedValueDetail", + "OperationDisplayInfo", + "OperationEntity", + "OperationEntityListResult", + "PredictionRequest", + "PredictionResponse", + "Resource", + "ResourceMetadata", + "ResourceRecommendationBase", + "ResourceRecommendationBaseListResult", + "ShortDescription", + "SuppressionContract", + "SuppressionContractListResult", + "Category", + "ConfigurationName", + "CpuThreshold", + "DigestConfigState", + "Duration", + "Impact", + "PredictionType", + "Risk", + "Scenario", ] +__all__.extend([p for p in _patch_all if p not in __all__]) +_patch_sdk() diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_advisor_management_client_enums.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_advisor_management_client_enums.py index e4d1caa3eae3d..9754441252103 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_advisor_management_client_enums.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_advisor_management_client_enums.py @@ -6,27 +6,12 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from enum import Enum, EnumMeta -from six import with_metaclass +from enum import Enum +from azure.core import CaseInsensitiveEnumMeta -class _CaseInsensitiveEnumMeta(EnumMeta): - def __getitem__(self, name): - return super().__getitem__(name.upper()) - def __getattr__(cls, name): - """Return the enum member matching `name` - We use __getattr__ instead of descriptors or inserting into the enum - class' __dict__ in order to support `name` and `value` being both - properties for enum members (which live in the class' __dict__) and - enum members themselves. - """ - try: - return cls._member_map_[name.upper()] - except KeyError: - raise AttributeError(name) - - -class Category(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): +class Category(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Category.""" HIGH_AVAILABILITY = "HighAvailability" SECURITY = "Security" @@ -34,11 +19,14 @@ class Category(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): COST = "Cost" OPERATIONAL_EXCELLENCE = "OperationalExcellence" -class ConfigurationName(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): + +class ConfigurationName(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """ConfigurationName.""" DEFAULT = "default" -class CpuThreshold(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): + +class CpuThreshold(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Minimum percentage threshold for Advisor low CPU utilization evaluation. Valid only for subscriptions. Valid values: 5 (default), 10, 15 or 20. """ @@ -48,29 +36,50 @@ class CpuThreshold(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): FIFTEEN = "15" TWENTY = "20" -class DigestConfigState(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): - """State of digest configuration. - """ + +class DigestConfigState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """State of digest configuration.""" ACTIVE = "Active" DISABLED = "Disabled" -class Impact(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): - """The business impact of the recommendation. + +class Duration(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Minimum duration for Advisor low CPU utilization evaluation. Valid only for subscriptions. + Valid values: 7 (default), 14, 21, 30, 60 or 90. """ + SEVEN = "7" + FOURTEEN = "14" + TWENTY_ONE = "21" + THIRTY = "30" + SIXTY = "60" + NINETY = "90" + + +class Impact(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """The business impact of the recommendation.""" + HIGH = "High" MEDIUM = "Medium" LOW = "Low" -class Risk(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): - """The potential risk of not implementing the recommendation. - """ + +class PredictionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Type of the prediction.""" + + PREDICTIVE_RIGHTSIZING = "PredictiveRightsizing" + + +class Risk(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """The potential risk of not implementing the recommendation.""" ERROR = "Error" WARNING = "Warning" NONE = "None" -class Scenario(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): + +class Scenario(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Scenario.""" ALERTS = "Alerts" diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_models.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_models.py index c61d143176dd6..33ec0b1be7492 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_models.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_models.py @@ -18,15 +18,12 @@ class ArmErrorResponse(msrest.serialization.Model): """ _attribute_map = { - 'error': {'key': 'error', 'type': 'ARMErrorResponseBody'}, + "error": {"key": "error", "type": "ARMErrorResponseBody"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(ArmErrorResponse, self).__init__(**kwargs) - self.error = kwargs.get('error', None) + self.error = kwargs.get("error", None) class ARMErrorResponseBody(msrest.serialization.Model): @@ -40,17 +37,14 @@ class ARMErrorResponseBody(msrest.serialization.Model): """ _attribute_map = { - 'message': {'key': 'message', 'type': 'str'}, - 'code': {'key': 'code', 'type': 'str'}, + "message": {"key": "message", "type": "str"}, + "code": {"key": "code", "type": "str"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(ARMErrorResponseBody, self).__init__(**kwargs) - self.message = kwargs.get('message', None) - self.code = kwargs.get('code', None) + self.message = kwargs.get("message", None) + self.code = kwargs.get("code", None) class Resource(msrest.serialization.Model): @@ -67,21 +61,18 @@ class Resource(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(Resource, self).__init__(**kwargs) self.id = None self.name = None @@ -111,28 +102,25 @@ class ConfigData(Resource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'exclude': {'key': 'properties.exclude', 'type': 'bool'}, - 'low_cpu_threshold': {'key': 'properties.lowCpuThreshold', 'type': 'str'}, - 'digests': {'key': 'properties.digests', 'type': '[DigestConfig]'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "exclude": {"key": "properties.exclude", "type": "bool"}, + "low_cpu_threshold": {"key": "properties.lowCpuThreshold", "type": "str"}, + "digests": {"key": "properties.digests", "type": "[DigestConfig]"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(ConfigData, self).__init__(**kwargs) - self.exclude = kwargs.get('exclude', None) - self.low_cpu_threshold = kwargs.get('low_cpu_threshold', None) - self.digests = kwargs.get('digests', None) + self.exclude = kwargs.get("exclude", None) + self.low_cpu_threshold = kwargs.get("low_cpu_threshold", None) + self.digests = kwargs.get("digests", None) class ConfigurationListResult(msrest.serialization.Model): @@ -145,17 +133,14 @@ class ConfigurationListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[ConfigData]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[ConfigData]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(ConfigurationListResult, self).__init__(**kwargs) - self.value = kwargs.get('value', None) - self.next_link = kwargs.get('next_link', None) + self.value = kwargs.get("value", None) + self.next_link = kwargs.get("next_link", None) class DigestConfig(msrest.serialization.Model): @@ -181,25 +166,22 @@ class DigestConfig(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'action_group_resource_id': {'key': 'actionGroupResourceId', 'type': 'str'}, - 'frequency': {'key': 'frequency', 'type': 'int'}, - 'categories': {'key': 'categories', 'type': '[str]'}, - 'language': {'key': 'language', 'type': 'str'}, - 'state': {'key': 'state', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "action_group_resource_id": {"key": "actionGroupResourceId", "type": "str"}, + "frequency": {"key": "frequency", "type": "int"}, + "categories": {"key": "categories", "type": "[str]"}, + "language": {"key": "language", "type": "str"}, + "state": {"key": "state", "type": "str"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(DigestConfig, self).__init__(**kwargs) - self.name = kwargs.get('name', None) - self.action_group_resource_id = kwargs.get('action_group_resource_id', None) - self.frequency = kwargs.get('frequency', None) - self.categories = kwargs.get('categories', None) - self.language = kwargs.get('language', None) - self.state = kwargs.get('state', None) + self.name = kwargs.get("name", None) + self.action_group_resource_id = kwargs.get("action_group_resource_id", None) + self.frequency = kwargs.get("frequency", None) + self.categories = kwargs.get("categories", None) + self.language = kwargs.get("language", None) + self.state = kwargs.get("state", None) class MetadataEntity(msrest.serialization.Model): @@ -222,27 +204,24 @@ class MetadataEntity(msrest.serialization.Model): """ _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'properties.displayName', 'type': 'str'}, - 'depends_on': {'key': 'properties.dependsOn', 'type': '[str]'}, - 'applicable_scenarios': {'key': 'properties.applicableScenarios', 'type': '[str]'}, - 'supported_values': {'key': 'properties.supportedValues', 'type': '[MetadataSupportedValueDetail]'}, + "id": {"key": "id", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "properties.displayName", "type": "str"}, + "depends_on": {"key": "properties.dependsOn", "type": "[str]"}, + "applicable_scenarios": {"key": "properties.applicableScenarios", "type": "[str]"}, + "supported_values": {"key": "properties.supportedValues", "type": "[MetadataSupportedValueDetail]"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(MetadataEntity, self).__init__(**kwargs) - self.id = kwargs.get('id', None) - self.type = kwargs.get('type', None) - self.name = kwargs.get('name', None) - self.display_name = kwargs.get('display_name', None) - self.depends_on = kwargs.get('depends_on', None) - self.applicable_scenarios = kwargs.get('applicable_scenarios', None) - self.supported_values = kwargs.get('supported_values', None) + self.id = kwargs.get("id", None) + self.type = kwargs.get("type", None) + self.name = kwargs.get("name", None) + self.display_name = kwargs.get("display_name", None) + self.depends_on = kwargs.get("depends_on", None) + self.applicable_scenarios = kwargs.get("applicable_scenarios", None) + self.supported_values = kwargs.get("supported_values", None) class MetadataEntityListResult(msrest.serialization.Model): @@ -255,17 +234,14 @@ class MetadataEntityListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[MetadataEntity]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[MetadataEntity]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(MetadataEntityListResult, self).__init__(**kwargs) - self.value = kwargs.get('value', None) - self.next_link = kwargs.get('next_link', None) + self.value = kwargs.get("value", None) + self.next_link = kwargs.get("next_link", None) class MetadataSupportedValueDetail(msrest.serialization.Model): @@ -278,17 +254,14 @@ class MetadataSupportedValueDetail(msrest.serialization.Model): """ _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(MetadataSupportedValueDetail, self).__init__(**kwargs) - self.id = kwargs.get('id', None) - self.display_name = kwargs.get('display_name', None) + self.id = kwargs.get("id", None) + self.display_name = kwargs.get("display_name", None) class OperationDisplayInfo(msrest.serialization.Model): @@ -305,21 +278,18 @@ class OperationDisplayInfo(msrest.serialization.Model): """ _attribute_map = { - 'description': {'key': 'description', 'type': 'str'}, - 'operation': {'key': 'operation', 'type': 'str'}, - 'provider': {'key': 'provider', 'type': 'str'}, - 'resource': {'key': 'resource', 'type': 'str'}, + "description": {"key": "description", "type": "str"}, + "operation": {"key": "operation", "type": "str"}, + "provider": {"key": "provider", "type": "str"}, + "resource": {"key": "resource", "type": "str"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(OperationDisplayInfo, self).__init__(**kwargs) - self.description = kwargs.get('description', None) - self.operation = kwargs.get('operation', None) - self.provider = kwargs.get('provider', None) - self.resource = kwargs.get('resource', None) + self.description = kwargs.get("description", None) + self.operation = kwargs.get("operation", None) + self.provider = kwargs.get("provider", None) + self.resource = kwargs.get("resource", None) class OperationEntity(msrest.serialization.Model): @@ -332,17 +302,14 @@ class OperationEntity(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display': {'key': 'display', 'type': 'OperationDisplayInfo'}, + "name": {"key": "name", "type": "str"}, + "display": {"key": "display", "type": "OperationDisplayInfo"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(OperationEntity, self).__init__(**kwargs) - self.name = kwargs.get('name', None) - self.display = kwargs.get('display', None) + self.name = kwargs.get("name", None) + self.display = kwargs.get("display", None) class OperationEntityListResult(msrest.serialization.Model): @@ -355,17 +322,14 @@ class OperationEntityListResult(msrest.serialization.Model): """ _attribute_map = { - 'next_link': {'key': 'nextLink', 'type': 'str'}, - 'value': {'key': 'value', 'type': '[OperationEntity]'}, + "next_link": {"key": "nextLink", "type": "str"}, + "value": {"key": "value", "type": "[OperationEntity]"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(OperationEntityListResult, self).__init__(**kwargs) - self.next_link = kwargs.get('next_link', None) - self.value = kwargs.get('value', None) + self.next_link = kwargs.get("next_link", None) + self.value = kwargs.get("value", None) class ResourceMetadata(msrest.serialization.Model): @@ -378,17 +342,14 @@ class ResourceMetadata(msrest.serialization.Model): """ _attribute_map = { - 'resource_id': {'key': 'resourceId', 'type': 'str'}, - 'source': {'key': 'source', 'type': 'str'}, + "resource_id": {"key": "resourceId", "type": "str"}, + "source": {"key": "source", "type": "str"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(ResourceMetadata, self).__init__(**kwargs) - self.resource_id = kwargs.get('resource_id', None) - self.source = kwargs.get('source', None) + self.resource_id = kwargs.get("resource_id", None) + self.source = kwargs.get("source", None) class ResourceRecommendationBase(Resource): @@ -433,46 +394,43 @@ class ResourceRecommendationBase(Resource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'category': {'key': 'properties.category', 'type': 'str'}, - 'impact': {'key': 'properties.impact', 'type': 'str'}, - 'impacted_field': {'key': 'properties.impactedField', 'type': 'str'}, - 'impacted_value': {'key': 'properties.impactedValue', 'type': 'str'}, - 'last_updated': {'key': 'properties.lastUpdated', 'type': 'iso-8601'}, - 'metadata': {'key': 'properties.metadata', 'type': '{object}'}, - 'recommendation_type_id': {'key': 'properties.recommendationTypeId', 'type': 'str'}, - 'risk': {'key': 'properties.risk', 'type': 'str'}, - 'short_description': {'key': 'properties.shortDescription', 'type': 'ShortDescription'}, - 'suppression_ids': {'key': 'properties.suppressionIds', 'type': '[str]'}, - 'extended_properties': {'key': 'properties.extendedProperties', 'type': '{str}'}, - 'resource_metadata': {'key': 'properties.resourceMetadata', 'type': 'ResourceMetadata'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "category": {"key": "properties.category", "type": "str"}, + "impact": {"key": "properties.impact", "type": "str"}, + "impacted_field": {"key": "properties.impactedField", "type": "str"}, + "impacted_value": {"key": "properties.impactedValue", "type": "str"}, + "last_updated": {"key": "properties.lastUpdated", "type": "iso-8601"}, + "metadata": {"key": "properties.metadata", "type": "{object}"}, + "recommendation_type_id": {"key": "properties.recommendationTypeId", "type": "str"}, + "risk": {"key": "properties.risk", "type": "str"}, + "short_description": {"key": "properties.shortDescription", "type": "ShortDescription"}, + "suppression_ids": {"key": "properties.suppressionIds", "type": "[str]"}, + "extended_properties": {"key": "properties.extendedProperties", "type": "{str}"}, + "resource_metadata": {"key": "properties.resourceMetadata", "type": "ResourceMetadata"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(ResourceRecommendationBase, self).__init__(**kwargs) - self.category = kwargs.get('category', None) - self.impact = kwargs.get('impact', None) - self.impacted_field = kwargs.get('impacted_field', None) - self.impacted_value = kwargs.get('impacted_value', None) - self.last_updated = kwargs.get('last_updated', None) - self.metadata = kwargs.get('metadata', None) - self.recommendation_type_id = kwargs.get('recommendation_type_id', None) - self.risk = kwargs.get('risk', None) - self.short_description = kwargs.get('short_description', None) - self.suppression_ids = kwargs.get('suppression_ids', None) - self.extended_properties = kwargs.get('extended_properties', None) - self.resource_metadata = kwargs.get('resource_metadata', None) + self.category = kwargs.get("category", None) + self.impact = kwargs.get("impact", None) + self.impacted_field = kwargs.get("impacted_field", None) + self.impacted_value = kwargs.get("impacted_value", None) + self.last_updated = kwargs.get("last_updated", None) + self.metadata = kwargs.get("metadata", None) + self.recommendation_type_id = kwargs.get("recommendation_type_id", None) + self.risk = kwargs.get("risk", None) + self.short_description = kwargs.get("short_description", None) + self.suppression_ids = kwargs.get("suppression_ids", None) + self.extended_properties = kwargs.get("extended_properties", None) + self.resource_metadata = kwargs.get("resource_metadata", None) class ResourceRecommendationBaseListResult(msrest.serialization.Model): @@ -485,17 +443,14 @@ class ResourceRecommendationBaseListResult(msrest.serialization.Model): """ _attribute_map = { - 'next_link': {'key': 'nextLink', 'type': 'str'}, - 'value': {'key': 'value', 'type': '[ResourceRecommendationBase]'}, + "next_link": {"key": "nextLink", "type": "str"}, + "value": {"key": "value", "type": "[ResourceRecommendationBase]"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(ResourceRecommendationBaseListResult, self).__init__(**kwargs) - self.next_link = kwargs.get('next_link', None) - self.value = kwargs.get('value', None) + self.next_link = kwargs.get("next_link", None) + self.value = kwargs.get("value", None) class ShortDescription(msrest.serialization.Model): @@ -508,17 +463,14 @@ class ShortDescription(msrest.serialization.Model): """ _attribute_map = { - 'problem': {'key': 'problem', 'type': 'str'}, - 'solution': {'key': 'solution', 'type': 'str'}, + "problem": {"key": "problem", "type": "str"}, + "solution": {"key": "solution", "type": "str"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(ShortDescription, self).__init__(**kwargs) - self.problem = kwargs.get('problem', None) - self.solution = kwargs.get('solution', None) + self.problem = kwargs.get("problem", None) + self.solution = kwargs.get("solution", None) class SuppressionContract(Resource): @@ -541,28 +493,25 @@ class SuppressionContract(Resource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'expiration_time_stamp': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "expiration_time_stamp": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'suppression_id': {'key': 'properties.suppressionId', 'type': 'str'}, - 'ttl': {'key': 'properties.ttl', 'type': 'str'}, - 'expiration_time_stamp': {'key': 'properties.expirationTimeStamp', 'type': 'iso-8601'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "suppression_id": {"key": "properties.suppressionId", "type": "str"}, + "ttl": {"key": "properties.ttl", "type": "str"}, + "expiration_time_stamp": {"key": "properties.expirationTimeStamp", "type": "iso-8601"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(SuppressionContract, self).__init__(**kwargs) - self.suppression_id = kwargs.get('suppression_id', None) - self.ttl = kwargs.get('ttl', None) + self.suppression_id = kwargs.get("suppression_id", None) + self.ttl = kwargs.get("ttl", None) self.expiration_time_stamp = None @@ -576,14 +525,11 @@ class SuppressionContractListResult(msrest.serialization.Model): """ _attribute_map = { - 'next_link': {'key': 'nextLink', 'type': 'str'}, - 'value': {'key': 'value', 'type': '[SuppressionContract]'}, + "next_link": {"key": "nextLink", "type": "str"}, + "value": {"key": "value", "type": "[SuppressionContract]"}, } - def __init__( - self, - **kwargs - ): + def __init__(self, **kwargs): super(SuppressionContractListResult, self).__init__(**kwargs) - self.next_link = kwargs.get('next_link', None) - self.value = kwargs.get('value', None) + self.next_link = kwargs.get("next_link", None) + self.value = kwargs.get("value", None) diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_models_py3.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_models_py3.py index 476150e82f268..84c5de9116ffb 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_models_py3.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_models_py3.py @@ -1,4 +1,5 @@ # coding=utf-8 +# pylint: disable=too-many-lines # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. @@ -7,63 +8,70 @@ # -------------------------------------------------------------------------- import datetime -from typing import Dict, List, Optional, Union +import sys +from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union -from azure.core.exceptions import HttpResponseError -import msrest.serialization +from .. import _serialization -from ._advisor_management_client_enums import * +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from .. import models as _models +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping +else: + from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports +JSON = MutableMapping[str, Any] # pylint: disable=unsubscriptable-object -class ArmErrorResponse(msrest.serialization.Model): +class ArmErrorResponse(_serialization.Model): """ArmErrorResponse. - :param error: ARM error response body. - :type error: ~azure.mgmt.advisor.models.ARMErrorResponseBody + :ivar error: ARM error response body. + :vartype error: ~azure.mgmt.advisor.models.ARMErrorResponseBody """ _attribute_map = { - 'error': {'key': 'error', 'type': 'ARMErrorResponseBody'}, + "error": {"key": "error", "type": "ARMErrorResponseBody"}, } - def __init__( - self, - *, - error: Optional["ARMErrorResponseBody"] = None, - **kwargs - ): - super(ArmErrorResponse, self).__init__(**kwargs) + def __init__(self, *, error: Optional["_models.ARMErrorResponseBody"] = None, **kwargs): + """ + :keyword error: ARM error response body. + :paramtype error: ~azure.mgmt.advisor.models.ARMErrorResponseBody + """ + super().__init__(**kwargs) self.error = error -class ARMErrorResponseBody(msrest.serialization.Model): +class ARMErrorResponseBody(_serialization.Model): """ARM error response body. - :param message: Gets or sets the string that describes the error in detail and provides + :ivar message: Gets or sets the string that describes the error in detail and provides debugging information. - :type message: str - :param code: Gets or sets the string that can be used to programmatically identify the error. - :type code: str + :vartype message: str + :ivar code: Gets or sets the string that can be used to programmatically identify the error. + :vartype code: str """ _attribute_map = { - 'message': {'key': 'message', 'type': 'str'}, - 'code': {'key': 'code', 'type': 'str'}, + "message": {"key": "message", "type": "str"}, + "code": {"key": "code", "type": "str"}, } - def __init__( - self, - *, - message: Optional[str] = None, - code: Optional[str] = None, - **kwargs - ): - super(ARMErrorResponseBody, self).__init__(**kwargs) + def __init__(self, *, message: Optional[str] = None, code: Optional[str] = None, **kwargs): + """ + :keyword message: Gets or sets the string that describes the error in detail and provides + debugging information. + :paramtype message: str + :keyword code: Gets or sets the string that can be used to programmatically identify the error. + :paramtype code: str + """ + super().__init__(**kwargs) self.message = message self.code = code -class Resource(msrest.serialization.Model): +class Resource(_serialization.Model): """An Azure resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -77,22 +85,20 @@ class Resource(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, } - def __init__( - self, - **kwargs - ): - super(Resource, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -109,101 +115,125 @@ class ConfigData(Resource): :vartype name: str :ivar type: The type of the resource. :vartype type: str - :param exclude: Exclude the resource from Advisor evaluations. Valid values: False (default) or + :ivar exclude: Exclude the resource from Advisor evaluations. Valid values: False (default) or True. - :type exclude: bool - :param low_cpu_threshold: Minimum percentage threshold for Advisor low CPU utilization - evaluation. Valid only for subscriptions. Valid values: 5 (default), 10, 15 or 20. Possible - values include: "5", "10", "15", "20". - :type low_cpu_threshold: str or ~azure.mgmt.advisor.models.CpuThreshold - :param digests: Advisor digest configuration. Valid only for subscriptions. - :type digests: list[~azure.mgmt.advisor.models.DigestConfig] + :vartype exclude: bool + :ivar low_cpu_threshold: Minimum percentage threshold for Advisor low CPU utilization + evaluation. Valid only for subscriptions. Valid values: 5 (default), 10, 15 or 20. Known values + are: "5", "10", "15", and "20". + :vartype low_cpu_threshold: str or ~azure.mgmt.advisor.models.CpuThreshold + :ivar duration: Minimum duration for Advisor low CPU utilization evaluation. Valid only for + subscriptions. Valid values: 7 (default), 14, 21, 30, 60 or 90. Known values are: "7", "14", + "21", "30", "60", and "90". + :vartype duration: str or ~azure.mgmt.advisor.models.Duration + :ivar digests: Advisor digest configuration. Valid only for subscriptions. + :vartype digests: list[~azure.mgmt.advisor.models.DigestConfig] """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'exclude': {'key': 'properties.exclude', 'type': 'bool'}, - 'low_cpu_threshold': {'key': 'properties.lowCpuThreshold', 'type': 'str'}, - 'digests': {'key': 'properties.digests', 'type': '[DigestConfig]'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "exclude": {"key": "properties.exclude", "type": "bool"}, + "low_cpu_threshold": {"key": "properties.lowCpuThreshold", "type": "str"}, + "duration": {"key": "properties.duration", "type": "str"}, + "digests": {"key": "properties.digests", "type": "[DigestConfig]"}, } def __init__( self, *, exclude: Optional[bool] = None, - low_cpu_threshold: Optional[Union[str, "CpuThreshold"]] = None, - digests: Optional[List["DigestConfig"]] = None, + low_cpu_threshold: Optional[Union[str, "_models.CpuThreshold"]] = None, + duration: Optional[Union[str, "_models.Duration"]] = None, + digests: Optional[List["_models.DigestConfig"]] = None, **kwargs ): - super(ConfigData, self).__init__(**kwargs) + """ + :keyword exclude: Exclude the resource from Advisor evaluations. Valid values: False (default) + or True. + :paramtype exclude: bool + :keyword low_cpu_threshold: Minimum percentage threshold for Advisor low CPU utilization + evaluation. Valid only for subscriptions. Valid values: 5 (default), 10, 15 or 20. Known values + are: "5", "10", "15", and "20". + :paramtype low_cpu_threshold: str or ~azure.mgmt.advisor.models.CpuThreshold + :keyword duration: Minimum duration for Advisor low CPU utilization evaluation. Valid only for + subscriptions. Valid values: 7 (default), 14, 21, 30, 60 or 90. Known values are: "7", "14", + "21", "30", "60", and "90". + :paramtype duration: str or ~azure.mgmt.advisor.models.Duration + :keyword digests: Advisor digest configuration. Valid only for subscriptions. + :paramtype digests: list[~azure.mgmt.advisor.models.DigestConfig] + """ + super().__init__(**kwargs) self.exclude = exclude self.low_cpu_threshold = low_cpu_threshold + self.duration = duration self.digests = digests -class ConfigurationListResult(msrest.serialization.Model): +class ConfigurationListResult(_serialization.Model): """The list of Advisor configurations. - :param value: The list of configurations. - :type value: list[~azure.mgmt.advisor.models.ConfigData] - :param next_link: The link used to get the next page of configurations. - :type next_link: str + :ivar value: The list of configurations. + :vartype value: list[~azure.mgmt.advisor.models.ConfigData] + :ivar next_link: The link used to get the next page of configurations. + :vartype next_link: str """ _attribute_map = { - 'value': {'key': 'value', 'type': '[ConfigData]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[ConfigData]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( - self, - *, - value: Optional[List["ConfigData"]] = None, - next_link: Optional[str] = None, - **kwargs + self, *, value: Optional[List["_models.ConfigData"]] = None, next_link: Optional[str] = None, **kwargs ): - super(ConfigurationListResult, self).__init__(**kwargs) + """ + :keyword value: The list of configurations. + :paramtype value: list[~azure.mgmt.advisor.models.ConfigData] + :keyword next_link: The link used to get the next page of configurations. + :paramtype next_link: str + """ + super().__init__(**kwargs) self.value = value self.next_link = next_link -class DigestConfig(msrest.serialization.Model): +class DigestConfig(_serialization.Model): """Advisor Digest configuration entity. - :param name: Name of digest configuration. Value is case-insensitive and must be unique within - a subscription. - :type name: str - :param action_group_resource_id: Action group resource id used by digest. - :type action_group_resource_id: str - :param frequency: Frequency that digest will be triggered, in days. Value must be between 7 and + :ivar name: Name of digest configuration. Value is case-insensitive and must be unique within a + subscription. + :vartype name: str + :ivar action_group_resource_id: Action group resource id used by digest. + :vartype action_group_resource_id: str + :ivar frequency: Frequency that digest will be triggered, in days. Value must be between 7 and 30 days inclusive. - :type frequency: int - :param categories: Categories to send digest for. If categories are not provided, then digest + :vartype frequency: int + :ivar categories: Categories to send digest for. If categories are not provided, then digest will be sent for all categories. - :type categories: list[str or ~azure.mgmt.advisor.models.Category] - :param language: Language for digest content body. Value must be ISO 639-1 code for one of - Azure portal supported languages. Otherwise, it will be converted into one. Default value is - English (en). - :type language: str - :param state: State of digest configuration. Possible values include: "Active", "Disabled". - :type state: str or ~azure.mgmt.advisor.models.DigestConfigState + :vartype categories: list[str or ~azure.mgmt.advisor.models.Category] + :ivar language: Language for digest content body. Value must be ISO 639-1 code for one of Azure + portal supported languages. Otherwise, it will be converted into one. Default value is English + (en). + :vartype language: str + :ivar state: State of digest configuration. Known values are: "Active" and "Disabled". + :vartype state: str or ~azure.mgmt.advisor.models.DigestConfigState """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'action_group_resource_id': {'key': 'actionGroupResourceId', 'type': 'str'}, - 'frequency': {'key': 'frequency', 'type': 'int'}, - 'categories': {'key': 'categories', 'type': '[str]'}, - 'language': {'key': 'language', 'type': 'str'}, - 'state': {'key': 'state', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "action_group_resource_id": {"key": "actionGroupResourceId", "type": "str"}, + "frequency": {"key": "frequency", "type": "int"}, + "categories": {"key": "categories", "type": "[str]"}, + "language": {"key": "language", "type": "str"}, + "state": {"key": "state", "type": "str"}, } def __init__( @@ -212,12 +242,31 @@ def __init__( name: Optional[str] = None, action_group_resource_id: Optional[str] = None, frequency: Optional[int] = None, - categories: Optional[List[Union[str, "Category"]]] = None, + categories: Optional[List[Union[str, "_models.Category"]]] = None, language: Optional[str] = None, - state: Optional[Union[str, "DigestConfigState"]] = None, + state: Optional[Union[str, "_models.DigestConfigState"]] = None, **kwargs ): - super(DigestConfig, self).__init__(**kwargs) + """ + :keyword name: Name of digest configuration. Value is case-insensitive and must be unique + within a subscription. + :paramtype name: str + :keyword action_group_resource_id: Action group resource id used by digest. + :paramtype action_group_resource_id: str + :keyword frequency: Frequency that digest will be triggered, in days. Value must be between 7 + and 30 days inclusive. + :paramtype frequency: int + :keyword categories: Categories to send digest for. If categories are not provided, then digest + will be sent for all categories. + :paramtype categories: list[str or ~azure.mgmt.advisor.models.Category] + :keyword language: Language for digest content body. Value must be ISO 639-1 code for one of + Azure portal supported languages. Otherwise, it will be converted into one. Default value is + English (en). + :paramtype language: str + :keyword state: State of digest configuration. Known values are: "Active" and "Disabled". + :paramtype state: str or ~azure.mgmt.advisor.models.DigestConfigState + """ + super().__init__(**kwargs) self.name = name self.action_group_resource_id = action_group_resource_id self.frequency = frequency @@ -226,48 +275,64 @@ def __init__( self.state = state -class MetadataEntity(msrest.serialization.Model): +class MetadataEntity(_serialization.Model): """The metadata entity contract. - :param id: The resource Id of the metadata entity. - :type id: str - :param type: The type of the metadata entity. - :type type: str - :param name: The name of the metadata entity. - :type name: str - :param display_name: The display name. - :type display_name: str - :param depends_on: The list of keys on which this entity depends on. - :type depends_on: list[str] - :param applicable_scenarios: The list of scenarios applicable to this metadata entity. - :type applicable_scenarios: list[str or ~azure.mgmt.advisor.models.Scenario] - :param supported_values: The list of supported values. - :type supported_values: list[~azure.mgmt.advisor.models.MetadataSupportedValueDetail] + :ivar id: The resource Id of the metadata entity. + :vartype id: str + :ivar type: The type of the metadata entity. + :vartype type: str + :ivar name: The name of the metadata entity. + :vartype name: str + :ivar display_name: The display name. + :vartype display_name: str + :ivar depends_on: The list of keys on which this entity depends on. + :vartype depends_on: list[str] + :ivar applicable_scenarios: The list of scenarios applicable to this metadata entity. + :vartype applicable_scenarios: list[str or ~azure.mgmt.advisor.models.Scenario] + :ivar supported_values: The list of supported values. + :vartype supported_values: list[~azure.mgmt.advisor.models.MetadataSupportedValueDetail] """ _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'display_name': {'key': 'properties.displayName', 'type': 'str'}, - 'depends_on': {'key': 'properties.dependsOn', 'type': '[str]'}, - 'applicable_scenarios': {'key': 'properties.applicableScenarios', 'type': '[str]'}, - 'supported_values': {'key': 'properties.supportedValues', 'type': '[MetadataSupportedValueDetail]'}, + "id": {"key": "id", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "properties.displayName", "type": "str"}, + "depends_on": {"key": "properties.dependsOn", "type": "[str]"}, + "applicable_scenarios": {"key": "properties.applicableScenarios", "type": "[str]"}, + "supported_values": {"key": "properties.supportedValues", "type": "[MetadataSupportedValueDetail]"}, } def __init__( self, *, - id: Optional[str] = None, + id: Optional[str] = None, # pylint: disable=redefined-builtin type: Optional[str] = None, name: Optional[str] = None, display_name: Optional[str] = None, depends_on: Optional[List[str]] = None, - applicable_scenarios: Optional[List[Union[str, "Scenario"]]] = None, - supported_values: Optional[List["MetadataSupportedValueDetail"]] = None, + applicable_scenarios: Optional[List[Union[str, "_models.Scenario"]]] = None, + supported_values: Optional[List["_models.MetadataSupportedValueDetail"]] = None, **kwargs ): - super(MetadataEntity, self).__init__(**kwargs) + """ + :keyword id: The resource Id of the metadata entity. + :paramtype id: str + :keyword type: The type of the metadata entity. + :paramtype type: str + :keyword name: The name of the metadata entity. + :paramtype name: str + :keyword display_name: The display name. + :paramtype display_name: str + :keyword depends_on: The list of keys on which this entity depends on. + :paramtype depends_on: list[str] + :keyword applicable_scenarios: The list of scenarios applicable to this metadata entity. + :paramtype applicable_scenarios: list[str or ~azure.mgmt.advisor.models.Scenario] + :keyword supported_values: The list of supported values. + :paramtype supported_values: list[~azure.mgmt.advisor.models.MetadataSupportedValueDetail] + """ + super().__init__(**kwargs) self.id = id self.type = type self.name = name @@ -277,76 +342,84 @@ def __init__( self.supported_values = supported_values -class MetadataEntityListResult(msrest.serialization.Model): +class MetadataEntityListResult(_serialization.Model): """The list of metadata entities. - :param value: The list of metadata entities. - :type value: list[~azure.mgmt.advisor.models.MetadataEntity] - :param next_link: The link used to get the next page of metadata. - :type next_link: str + :ivar value: The list of metadata entities. + :vartype value: list[~azure.mgmt.advisor.models.MetadataEntity] + :ivar next_link: The link used to get the next page of metadata. + :vartype next_link: str """ _attribute_map = { - 'value': {'key': 'value', 'type': '[MetadataEntity]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[MetadataEntity]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( - self, - *, - value: Optional[List["MetadataEntity"]] = None, - next_link: Optional[str] = None, - **kwargs + self, *, value: Optional[List["_models.MetadataEntity"]] = None, next_link: Optional[str] = None, **kwargs ): - super(MetadataEntityListResult, self).__init__(**kwargs) + """ + :keyword value: The list of metadata entities. + :paramtype value: list[~azure.mgmt.advisor.models.MetadataEntity] + :keyword next_link: The link used to get the next page of metadata. + :paramtype next_link: str + """ + super().__init__(**kwargs) self.value = value self.next_link = next_link -class MetadataSupportedValueDetail(msrest.serialization.Model): +class MetadataSupportedValueDetail(_serialization.Model): """The metadata supported value detail. - :param id: The id. - :type id: str - :param display_name: The display name. - :type display_name: str + :ivar id: The id. + :vartype id: str + :ivar display_name: The display name. + :vartype display_name: str """ _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, } def __init__( self, *, - id: Optional[str] = None, + id: Optional[str] = None, # pylint: disable=redefined-builtin display_name: Optional[str] = None, **kwargs ): - super(MetadataSupportedValueDetail, self).__init__(**kwargs) + """ + :keyword id: The id. + :paramtype id: str + :keyword display_name: The display name. + :paramtype display_name: str + """ + super().__init__(**kwargs) self.id = id self.display_name = display_name -class OperationDisplayInfo(msrest.serialization.Model): +class OperationDisplayInfo(_serialization.Model): """The operation supported by Advisor. - :param description: The description of the operation. - :type description: str - :param operation: The action that users can perform, based on their permission level. - :type operation: str - :param provider: Service provider: Microsoft Advisor. - :type provider: str - :param resource: Resource on which the operation is performed. - :type resource: str + :ivar description: The description of the operation. + :vartype description: str + :ivar operation: The action that users can perform, based on their permission level. + :vartype operation: str + :ivar provider: Service provider: Microsoft Advisor. + :vartype provider: str + :ivar resource: Resource on which the operation is performed. + :vartype resource: str """ _attribute_map = { - 'description': {'key': 'description', 'type': 'str'}, - 'operation': {'key': 'operation', 'type': 'str'}, - 'provider': {'key': 'provider', 'type': 'str'}, - 'resource': {'key': 'resource', 'type': 'str'}, + "description": {"key": "description", "type": "str"}, + "operation": {"key": "operation", "type": "str"}, + "provider": {"key": "provider", "type": "str"}, + "resource": {"key": "resource", "type": "str"}, } def __init__( @@ -358,77 +431,206 @@ def __init__( resource: Optional[str] = None, **kwargs ): - super(OperationDisplayInfo, self).__init__(**kwargs) + """ + :keyword description: The description of the operation. + :paramtype description: str + :keyword operation: The action that users can perform, based on their permission level. + :paramtype operation: str + :keyword provider: Service provider: Microsoft Advisor. + :paramtype provider: str + :keyword resource: Resource on which the operation is performed. + :paramtype resource: str + """ + super().__init__(**kwargs) self.description = description self.operation = operation self.provider = provider self.resource = resource -class OperationEntity(msrest.serialization.Model): +class OperationEntity(_serialization.Model): """The operation supported by Advisor. - :param name: Operation name: {provider}/{resource}/{operation}. - :type name: str - :param display: The operation supported by Advisor. - :type display: ~azure.mgmt.advisor.models.OperationDisplayInfo + :ivar name: Operation name: {provider}/{resource}/{operation}. + :vartype name: str + :ivar display: The operation supported by Advisor. + :vartype display: ~azure.mgmt.advisor.models.OperationDisplayInfo """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display': {'key': 'display', 'type': 'OperationDisplayInfo'}, + "name": {"key": "name", "type": "str"}, + "display": {"key": "display", "type": "OperationDisplayInfo"}, } def __init__( - self, - *, - name: Optional[str] = None, - display: Optional["OperationDisplayInfo"] = None, - **kwargs + self, *, name: Optional[str] = None, display: Optional["_models.OperationDisplayInfo"] = None, **kwargs ): - super(OperationEntity, self).__init__(**kwargs) + """ + :keyword name: Operation name: {provider}/{resource}/{operation}. + :paramtype name: str + :keyword display: The operation supported by Advisor. + :paramtype display: ~azure.mgmt.advisor.models.OperationDisplayInfo + """ + super().__init__(**kwargs) self.name = name self.display = display -class OperationEntityListResult(msrest.serialization.Model): +class OperationEntityListResult(_serialization.Model): """The list of Advisor operations. - :param next_link: The link used to get the next page of operations. - :type next_link: str - :param value: The list of operations. - :type value: list[~azure.mgmt.advisor.models.OperationEntity] + :ivar next_link: The link used to get the next page of operations. + :vartype next_link: str + :ivar value: The list of operations. + :vartype value: list[~azure.mgmt.advisor.models.OperationEntity] """ _attribute_map = { - 'next_link': {'key': 'nextLink', 'type': 'str'}, - 'value': {'key': 'value', 'type': '[OperationEntity]'}, + "next_link": {"key": "nextLink", "type": "str"}, + "value": {"key": "value", "type": "[OperationEntity]"}, + } + + def __init__( + self, *, next_link: Optional[str] = None, value: Optional[List["_models.OperationEntity"]] = None, **kwargs + ): + """ + :keyword next_link: The link used to get the next page of operations. + :paramtype next_link: str + :keyword value: The list of operations. + :paramtype value: list[~azure.mgmt.advisor.models.OperationEntity] + """ + super().__init__(**kwargs) + self.next_link = next_link + self.value = value + + +class PredictionRequest(_serialization.Model): + """Parameters for predict recommendation. + + :ivar prediction_type: Type of the prediction. "PredictiveRightsizing" + :vartype prediction_type: str or ~azure.mgmt.advisor.models.PredictionType + :ivar extended_properties: Extended properties are arguments specific for each prediction type. + :vartype extended_properties: JSON + """ + + _attribute_map = { + "prediction_type": {"key": "properties.predictionType", "type": "str"}, + "extended_properties": {"key": "properties.extendedProperties", "type": "object"}, } def __init__( self, *, - next_link: Optional[str] = None, - value: Optional[List["OperationEntity"]] = None, + prediction_type: Optional[Union[str, "_models.PredictionType"]] = None, + extended_properties: Optional[JSON] = None, **kwargs ): - super(OperationEntityListResult, self).__init__(**kwargs) - self.next_link = next_link - self.value = value + """ + :keyword prediction_type: Type of the prediction. "PredictiveRightsizing" + :paramtype prediction_type: str or ~azure.mgmt.advisor.models.PredictionType + :keyword extended_properties: Extended properties are arguments specific for each prediction + type. + :paramtype extended_properties: JSON + """ + super().__init__(**kwargs) + self.prediction_type = prediction_type + self.extended_properties = extended_properties + + +class PredictionResponse(_serialization.Model): + """Response used by predictions. + + :ivar extended_properties: Extended properties. + :vartype extended_properties: JSON + :ivar prediction_type: Type of the prediction. "PredictiveRightsizing" + :vartype prediction_type: str or ~azure.mgmt.advisor.models.PredictionType + :ivar category: The category of the recommendation. Known values are: "HighAvailability", + "Security", "Performance", "Cost", and "OperationalExcellence". + :vartype category: str or ~azure.mgmt.advisor.models.Category + :ivar impact: The business impact of the recommendation. Known values are: "High", "Medium", + and "Low". + :vartype impact: str or ~azure.mgmt.advisor.models.Impact + :ivar impacted_field: The resource type identified by Advisor. + :vartype impacted_field: str + :ivar last_updated: The most recent time that Advisor checked the validity of the + recommendation. + :vartype last_updated: ~datetime.datetime + :ivar short_description: A summary of the recommendation. + :vartype short_description: ~azure.mgmt.advisor.models.ShortDescription + """ + + _attribute_map = { + "extended_properties": {"key": "properties.extendedProperties", "type": "object"}, + "prediction_type": {"key": "properties.predictionType", "type": "str"}, + "category": {"key": "properties.category", "type": "str"}, + "impact": {"key": "properties.impact", "type": "str"}, + "impacted_field": {"key": "properties.impactedField", "type": "str"}, + "last_updated": {"key": "properties.lastUpdated", "type": "iso-8601"}, + "short_description": {"key": "properties.shortDescription", "type": "ShortDescription"}, + } + + def __init__( + self, + *, + extended_properties: Optional[JSON] = None, + prediction_type: Optional[Union[str, "_models.PredictionType"]] = None, + category: Optional[Union[str, "_models.Category"]] = None, + impact: Optional[Union[str, "_models.Impact"]] = None, + impacted_field: Optional[str] = None, + last_updated: Optional[datetime.datetime] = None, + short_description: Optional["_models.ShortDescription"] = None, + **kwargs + ): + """ + :keyword extended_properties: Extended properties. + :paramtype extended_properties: JSON + :keyword prediction_type: Type of the prediction. "PredictiveRightsizing" + :paramtype prediction_type: str or ~azure.mgmt.advisor.models.PredictionType + :keyword category: The category of the recommendation. Known values are: "HighAvailability", + "Security", "Performance", "Cost", and "OperationalExcellence". + :paramtype category: str or ~azure.mgmt.advisor.models.Category + :keyword impact: The business impact of the recommendation. Known values are: "High", "Medium", + and "Low". + :paramtype impact: str or ~azure.mgmt.advisor.models.Impact + :keyword impacted_field: The resource type identified by Advisor. + :paramtype impacted_field: str + :keyword last_updated: The most recent time that Advisor checked the validity of the + recommendation. + :paramtype last_updated: ~datetime.datetime + :keyword short_description: A summary of the recommendation. + :paramtype short_description: ~azure.mgmt.advisor.models.ShortDescription + """ + super().__init__(**kwargs) + self.extended_properties = extended_properties + self.prediction_type = prediction_type + self.category = category + self.impact = impact + self.impacted_field = impacted_field + self.last_updated = last_updated + self.short_description = short_description -class ResourceMetadata(msrest.serialization.Model): +class ResourceMetadata(_serialization.Model): """Recommendation resource metadata. - :param resource_id: Azure resource Id of the assessed resource. - :type resource_id: str - :param source: Source from which recommendation is generated. - :type source: str + :ivar resource_id: Azure resource Id of the assessed resource. + :vartype resource_id: str + :ivar source: Source from which recommendation is generated. + :vartype source: str + :ivar action: The action to view resource. + :vartype action: dict[str, JSON] + :ivar singular: The singular user friendly name of resource type. eg: virtual machine. + :vartype singular: str + :ivar plural: The plural user friendly name of resource type. eg: virtual machines. + :vartype plural: str """ _attribute_map = { - 'resource_id': {'key': 'resourceId', 'type': 'str'}, - 'source': {'key': 'source', 'type': 'str'}, + "resource_id": {"key": "resourceId", "type": "str"}, + "source": {"key": "source", "type": "str"}, + "action": {"key": "action", "type": "{object}"}, + "singular": {"key": "singular", "type": "str"}, + "plural": {"key": "plural", "type": "str"}, } def __init__( @@ -436,14 +638,32 @@ def __init__( *, resource_id: Optional[str] = None, source: Optional[str] = None, + action: Optional[Dict[str, JSON]] = None, + singular: Optional[str] = None, + plural: Optional[str] = None, **kwargs ): - super(ResourceMetadata, self).__init__(**kwargs) + """ + :keyword resource_id: Azure resource Id of the assessed resource. + :paramtype resource_id: str + :keyword source: Source from which recommendation is generated. + :paramtype source: str + :keyword action: The action to view resource. + :paramtype action: dict[str, JSON] + :keyword singular: The singular user friendly name of resource type. eg: virtual machine. + :paramtype singular: str + :keyword plural: The plural user friendly name of resource type. eg: virtual machines. + :paramtype plural: str + """ + super().__init__(**kwargs) self.resource_id = resource_id self.source = source + self.action = action + self.singular = singular + self.plural = plural -class ResourceRecommendationBase(Resource): +class ResourceRecommendationBase(Resource): # pylint: disable=too-many-instance-attributes """Advisor Recommendation. Variables are only populated by the server, and will be ignored when sending a request. @@ -454,78 +674,152 @@ class ResourceRecommendationBase(Resource): :vartype name: str :ivar type: The type of the resource. :vartype type: str - :param category: The category of the recommendation. Possible values include: - "HighAvailability", "Security", "Performance", "Cost", "OperationalExcellence". - :type category: str or ~azure.mgmt.advisor.models.Category - :param impact: The business impact of the recommendation. Possible values include: "High", - "Medium", "Low". - :type impact: str or ~azure.mgmt.advisor.models.Impact - :param impacted_field: The resource type identified by Advisor. - :type impacted_field: str - :param impacted_value: The resource identified by Advisor. - :type impacted_value: str - :param last_updated: The most recent time that Advisor checked the validity of the + :ivar category: The category of the recommendation. Known values are: "HighAvailability", + "Security", "Performance", "Cost", and "OperationalExcellence". + :vartype category: str or ~azure.mgmt.advisor.models.Category + :ivar impact: The business impact of the recommendation. Known values are: "High", "Medium", + and "Low". + :vartype impact: str or ~azure.mgmt.advisor.models.Impact + :ivar impacted_field: The resource type identified by Advisor. + :vartype impacted_field: str + :ivar impacted_value: The resource identified by Advisor. + :vartype impacted_value: str + :ivar last_updated: The most recent time that Advisor checked the validity of the recommendation. - :type last_updated: ~datetime.datetime - :param metadata: The recommendation metadata. - :type metadata: dict[str, object] - :param recommendation_type_id: The recommendation-type GUID. - :type recommendation_type_id: str - :param risk: The potential risk of not implementing the recommendation. Possible values - include: "Error", "Warning", "None". - :type risk: str or ~azure.mgmt.advisor.models.Risk - :param short_description: A summary of the recommendation. - :type short_description: ~azure.mgmt.advisor.models.ShortDescription - :param suppression_ids: The list of snoozed and dismissed rules for the recommendation. - :type suppression_ids: list[str] - :param extended_properties: Extended properties. - :type extended_properties: dict[str, str] - :param resource_metadata: Metadata of resource that was assessed. - :type resource_metadata: ~azure.mgmt.advisor.models.ResourceMetadata + :vartype last_updated: ~datetime.datetime + :ivar metadata: The recommendation metadata. + :vartype metadata: dict[str, JSON] + :ivar recommendation_type_id: The recommendation-type GUID. + :vartype recommendation_type_id: str + :ivar risk: The potential risk of not implementing the recommendation. Known values are: + "Error", "Warning", and "None". + :vartype risk: str or ~azure.mgmt.advisor.models.Risk + :ivar short_description: A summary of the recommendation. + :vartype short_description: ~azure.mgmt.advisor.models.ShortDescription + :ivar suppression_ids: The list of snoozed and dismissed rules for the recommendation. + :vartype suppression_ids: list[str] + :ivar extended_properties: Extended properties. + :vartype extended_properties: dict[str, str] + :ivar resource_metadata: Metadata of resource that was assessed. + :vartype resource_metadata: ~azure.mgmt.advisor.models.ResourceMetadata + :ivar description: The detailed description of recommendation. + :vartype description: str + :ivar label: The label of recommendation. + :vartype label: str + :ivar learn_more_link: The link to learn more about recommendation and generation logic. + :vartype learn_more_link: str + :ivar potential_benefits: The potential benefit of implementing recommendation. + :vartype potential_benefits: str + :ivar actions: The list of recommended actions to implement recommendation. + :vartype actions: list[dict[str, JSON]] + :ivar remediation: The automated way to apply recommendation. + :vartype remediation: dict[str, JSON] + :ivar exposed_metadata_properties: The recommendation metadata properties exposed to customer + to provide additional information. + :vartype exposed_metadata_properties: dict[str, JSON] """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'category': {'key': 'properties.category', 'type': 'str'}, - 'impact': {'key': 'properties.impact', 'type': 'str'}, - 'impacted_field': {'key': 'properties.impactedField', 'type': 'str'}, - 'impacted_value': {'key': 'properties.impactedValue', 'type': 'str'}, - 'last_updated': {'key': 'properties.lastUpdated', 'type': 'iso-8601'}, - 'metadata': {'key': 'properties.metadata', 'type': '{object}'}, - 'recommendation_type_id': {'key': 'properties.recommendationTypeId', 'type': 'str'}, - 'risk': {'key': 'properties.risk', 'type': 'str'}, - 'short_description': {'key': 'properties.shortDescription', 'type': 'ShortDescription'}, - 'suppression_ids': {'key': 'properties.suppressionIds', 'type': '[str]'}, - 'extended_properties': {'key': 'properties.extendedProperties', 'type': '{str}'}, - 'resource_metadata': {'key': 'properties.resourceMetadata', 'type': 'ResourceMetadata'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "category": {"key": "properties.category", "type": "str"}, + "impact": {"key": "properties.impact", "type": "str"}, + "impacted_field": {"key": "properties.impactedField", "type": "str"}, + "impacted_value": {"key": "properties.impactedValue", "type": "str"}, + "last_updated": {"key": "properties.lastUpdated", "type": "iso-8601"}, + "metadata": {"key": "properties.metadata", "type": "{object}"}, + "recommendation_type_id": {"key": "properties.recommendationTypeId", "type": "str"}, + "risk": {"key": "properties.risk", "type": "str"}, + "short_description": {"key": "properties.shortDescription", "type": "ShortDescription"}, + "suppression_ids": {"key": "properties.suppressionIds", "type": "[str]"}, + "extended_properties": {"key": "properties.extendedProperties", "type": "{str}"}, + "resource_metadata": {"key": "properties.resourceMetadata", "type": "ResourceMetadata"}, + "description": {"key": "properties.description", "type": "str"}, + "label": {"key": "properties.label", "type": "str"}, + "learn_more_link": {"key": "properties.learnMoreLink", "type": "str"}, + "potential_benefits": {"key": "properties.potentialBenefits", "type": "str"}, + "actions": {"key": "properties.actions", "type": "[{object}]"}, + "remediation": {"key": "properties.remediation", "type": "{object}"}, + "exposed_metadata_properties": {"key": "properties.exposedMetadataProperties", "type": "{object}"}, } def __init__( self, *, - category: Optional[Union[str, "Category"]] = None, - impact: Optional[Union[str, "Impact"]] = None, + category: Optional[Union[str, "_models.Category"]] = None, + impact: Optional[Union[str, "_models.Impact"]] = None, impacted_field: Optional[str] = None, impacted_value: Optional[str] = None, last_updated: Optional[datetime.datetime] = None, - metadata: Optional[Dict[str, object]] = None, + metadata: Optional[Dict[str, JSON]] = None, recommendation_type_id: Optional[str] = None, - risk: Optional[Union[str, "Risk"]] = None, - short_description: Optional["ShortDescription"] = None, + risk: Optional[Union[str, "_models.Risk"]] = None, + short_description: Optional["_models.ShortDescription"] = None, suppression_ids: Optional[List[str]] = None, extended_properties: Optional[Dict[str, str]] = None, - resource_metadata: Optional["ResourceMetadata"] = None, + resource_metadata: Optional["_models.ResourceMetadata"] = None, + description: Optional[str] = None, + label: Optional[str] = None, + learn_more_link: Optional[str] = None, + potential_benefits: Optional[str] = None, + actions: Optional[List[Dict[str, JSON]]] = None, + remediation: Optional[Dict[str, JSON]] = None, + exposed_metadata_properties: Optional[Dict[str, JSON]] = None, **kwargs ): - super(ResourceRecommendationBase, self).__init__(**kwargs) + """ + :keyword category: The category of the recommendation. Known values are: "HighAvailability", + "Security", "Performance", "Cost", and "OperationalExcellence". + :paramtype category: str or ~azure.mgmt.advisor.models.Category + :keyword impact: The business impact of the recommendation. Known values are: "High", "Medium", + and "Low". + :paramtype impact: str or ~azure.mgmt.advisor.models.Impact + :keyword impacted_field: The resource type identified by Advisor. + :paramtype impacted_field: str + :keyword impacted_value: The resource identified by Advisor. + :paramtype impacted_value: str + :keyword last_updated: The most recent time that Advisor checked the validity of the + recommendation. + :paramtype last_updated: ~datetime.datetime + :keyword metadata: The recommendation metadata. + :paramtype metadata: dict[str, JSON] + :keyword recommendation_type_id: The recommendation-type GUID. + :paramtype recommendation_type_id: str + :keyword risk: The potential risk of not implementing the recommendation. Known values are: + "Error", "Warning", and "None". + :paramtype risk: str or ~azure.mgmt.advisor.models.Risk + :keyword short_description: A summary of the recommendation. + :paramtype short_description: ~azure.mgmt.advisor.models.ShortDescription + :keyword suppression_ids: The list of snoozed and dismissed rules for the recommendation. + :paramtype suppression_ids: list[str] + :keyword extended_properties: Extended properties. + :paramtype extended_properties: dict[str, str] + :keyword resource_metadata: Metadata of resource that was assessed. + :paramtype resource_metadata: ~azure.mgmt.advisor.models.ResourceMetadata + :keyword description: The detailed description of recommendation. + :paramtype description: str + :keyword label: The label of recommendation. + :paramtype label: str + :keyword learn_more_link: The link to learn more about recommendation and generation logic. + :paramtype learn_more_link: str + :keyword potential_benefits: The potential benefit of implementing recommendation. + :paramtype potential_benefits: str + :keyword actions: The list of recommended actions to implement recommendation. + :paramtype actions: list[dict[str, JSON]] + :keyword remediation: The automated way to apply recommendation. + :paramtype remediation: dict[str, JSON] + :keyword exposed_metadata_properties: The recommendation metadata properties exposed to + customer to provide additional information. + :paramtype exposed_metadata_properties: dict[str, JSON] + """ + super().__init__(**kwargs) self.category = category self.impact = impact self.impacted_field = impacted_field @@ -538,56 +832,72 @@ def __init__( self.suppression_ids = suppression_ids self.extended_properties = extended_properties self.resource_metadata = resource_metadata + self.description = description + self.label = label + self.learn_more_link = learn_more_link + self.potential_benefits = potential_benefits + self.actions = actions + self.remediation = remediation + self.exposed_metadata_properties = exposed_metadata_properties -class ResourceRecommendationBaseListResult(msrest.serialization.Model): +class ResourceRecommendationBaseListResult(_serialization.Model): """The list of Advisor recommendations. - :param next_link: The link used to get the next page of recommendations. - :type next_link: str - :param value: The list of recommendations. - :type value: list[~azure.mgmt.advisor.models.ResourceRecommendationBase] + :ivar next_link: The link used to get the next page of recommendations. + :vartype next_link: str + :ivar value: The list of recommendations. + :vartype value: list[~azure.mgmt.advisor.models.ResourceRecommendationBase] """ _attribute_map = { - 'next_link': {'key': 'nextLink', 'type': 'str'}, - 'value': {'key': 'value', 'type': '[ResourceRecommendationBase]'}, + "next_link": {"key": "nextLink", "type": "str"}, + "value": {"key": "value", "type": "[ResourceRecommendationBase]"}, } def __init__( self, *, next_link: Optional[str] = None, - value: Optional[List["ResourceRecommendationBase"]] = None, + value: Optional[List["_models.ResourceRecommendationBase"]] = None, **kwargs ): - super(ResourceRecommendationBaseListResult, self).__init__(**kwargs) + """ + :keyword next_link: The link used to get the next page of recommendations. + :paramtype next_link: str + :keyword value: The list of recommendations. + :paramtype value: list[~azure.mgmt.advisor.models.ResourceRecommendationBase] + """ + super().__init__(**kwargs) self.next_link = next_link self.value = value -class ShortDescription(msrest.serialization.Model): +class ShortDescription(_serialization.Model): """A summary of the recommendation. - :param problem: The issue or opportunity identified by the recommendation. - :type problem: str - :param solution: The remediation action suggested by the recommendation. - :type solution: str + :ivar problem: The issue or opportunity identified by the recommendation and proposed solution. + :vartype problem: str + :ivar solution: The issue or opportunity identified by the recommendation and proposed + solution. + :vartype solution: str """ _attribute_map = { - 'problem': {'key': 'problem', 'type': 'str'}, - 'solution': {'key': 'solution', 'type': 'str'}, + "problem": {"key": "problem", "type": "str"}, + "solution": {"key": "solution", "type": "str"}, } - def __init__( - self, - *, - problem: Optional[str] = None, - solution: Optional[str] = None, - **kwargs - ): - super(ShortDescription, self).__init__(**kwargs) + def __init__(self, *, problem: Optional[str] = None, solution: Optional[str] = None, **kwargs): + """ + :keyword problem: The issue or opportunity identified by the recommendation and proposed + solution. + :paramtype problem: str + :keyword solution: The issue or opportunity identified by the recommendation and proposed + solution. + :paramtype solution: str + """ + super().__init__(**kwargs) self.problem = problem self.solution = solution @@ -603,64 +913,66 @@ class SuppressionContract(Resource): :vartype name: str :ivar type: The type of the resource. :vartype type: str - :param suppression_id: The GUID of the suppression. - :type suppression_id: str - :param ttl: The duration for which the suppression is valid. - :type ttl: str + :ivar suppression_id: The GUID of the suppression. + :vartype suppression_id: str + :ivar ttl: The duration for which the suppression is valid. + :vartype ttl: str :ivar expiration_time_stamp: Gets or sets the expiration time stamp. :vartype expiration_time_stamp: ~datetime.datetime """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'expiration_time_stamp': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "expiration_time_stamp": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'suppression_id': {'key': 'properties.suppressionId', 'type': 'str'}, - 'ttl': {'key': 'properties.ttl', 'type': 'str'}, - 'expiration_time_stamp': {'key': 'properties.expirationTimeStamp', 'type': 'iso-8601'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "suppression_id": {"key": "properties.suppressionId", "type": "str"}, + "ttl": {"key": "properties.ttl", "type": "str"}, + "expiration_time_stamp": {"key": "properties.expirationTimeStamp", "type": "iso-8601"}, } - def __init__( - self, - *, - suppression_id: Optional[str] = None, - ttl: Optional[str] = None, - **kwargs - ): - super(SuppressionContract, self).__init__(**kwargs) + def __init__(self, *, suppression_id: Optional[str] = None, ttl: Optional[str] = None, **kwargs): + """ + :keyword suppression_id: The GUID of the suppression. + :paramtype suppression_id: str + :keyword ttl: The duration for which the suppression is valid. + :paramtype ttl: str + """ + super().__init__(**kwargs) self.suppression_id = suppression_id self.ttl = ttl self.expiration_time_stamp = None -class SuppressionContractListResult(msrest.serialization.Model): +class SuppressionContractListResult(_serialization.Model): """The list of Advisor suppressions. - :param next_link: The link used to get the next page of suppressions. - :type next_link: str - :param value: The list of suppressions. - :type value: list[~azure.mgmt.advisor.models.SuppressionContract] + :ivar next_link: The link used to get the next page of suppressions. + :vartype next_link: str + :ivar value: The list of suppressions. + :vartype value: list[~azure.mgmt.advisor.models.SuppressionContract] """ _attribute_map = { - 'next_link': {'key': 'nextLink', 'type': 'str'}, - 'value': {'key': 'value', 'type': '[SuppressionContract]'}, + "next_link": {"key": "nextLink", "type": "str"}, + "value": {"key": "value", "type": "[SuppressionContract]"}, } def __init__( - self, - *, - next_link: Optional[str] = None, - value: Optional[List["SuppressionContract"]] = None, - **kwargs + self, *, next_link: Optional[str] = None, value: Optional[List["_models.SuppressionContract"]] = None, **kwargs ): - super(SuppressionContractListResult, self).__init__(**kwargs) + """ + :keyword next_link: The link used to get the next page of suppressions. + :paramtype next_link: str + :keyword value: The list of suppressions. + :paramtype value: list[~azure.mgmt.advisor.models.SuppressionContract] + """ + super().__init__(**kwargs) self.next_link = next_link self.value = value diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_patch.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_patch.py new file mode 100644 index 0000000000000..f7dd32510333d --- /dev/null +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/models/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/__init__.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/__init__.py index 090d96c72181f..5d68c12533564 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/__init__.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/__init__.py @@ -11,11 +11,19 @@ from ._recommendations_operations import RecommendationsOperations from ._operations import Operations from ._suppressions_operations import SuppressionsOperations +from ._advisor_management_client_operations import AdvisorManagementClientOperationsMixin + +from ._patch import __all__ as _patch_all +from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import patch_sdk as _patch_sdk __all__ = [ - 'RecommendationMetadataOperations', - 'ConfigurationsOperations', - 'RecommendationsOperations', - 'Operations', - 'SuppressionsOperations', + "RecommendationMetadataOperations", + "ConfigurationsOperations", + "RecommendationsOperations", + "Operations", + "SuppressionsOperations", + "AdvisorManagementClientOperationsMixin", ] +__all__.extend([p for p in _patch_all if p not in __all__]) +_patch_sdk() diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_advisor_management_client_operations.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_advisor_management_client_operations.py new file mode 100644 index 0000000000000..c062bbb33c8f1 --- /dev/null +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_advisor_management_client_operations.py @@ -0,0 +1,176 @@ +# pylint: disable=too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) +from azure.core.pipeline import PipelineResponse +from azure.core.pipeline.transport import HttpResponse +from azure.core.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 MixinABC, _convert_request, _format_url_section + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_predict_request(subscription_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/predict") + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + + +class AdvisorManagementClientOperationsMixin(MixinABC): + @overload + def predict( + self, prediction_request: _models.PredictionRequest, *, content_type: str = "application/json", **kwargs: Any + ) -> _models.PredictionResponse: + """Predicts a recommendation. + + Predicts a recommendation. + + :param prediction_request: Parameters for predict recommendation. Required. + :type prediction_request: ~azure.mgmt.advisor.models.PredictionRequest + :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: PredictionResponse or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.PredictionResponse + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def predict( + self, prediction_request: IO, *, content_type: str = "application/json", **kwargs: Any + ) -> _models.PredictionResponse: + """Predicts a recommendation. + + Predicts a recommendation. + + :param prediction_request: Parameters for predict recommendation. Required. + :type prediction_request: 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: PredictionResponse or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.PredictionResponse + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def predict( + self, prediction_request: Union[_models.PredictionRequest, IO], **kwargs: Any + ) -> _models.PredictionResponse: + """Predicts a recommendation. + + Predicts a recommendation. + + :param prediction_request: Parameters for predict recommendation. Is either a model type or a + IO type. Required. + :type prediction_request: ~azure.mgmt.advisor.models.PredictionRequest 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: PredictionResponse or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.PredictionResponse + :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 = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PredictionResponse] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(prediction_request, (IO, bytes)): + _content = prediction_request + else: + _json = self._serialize.body(prediction_request, "PredictionRequest") + + request = build_predict_request( + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.predict.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + + response = 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.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("PredictionResponse", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + predict.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/predict"} # type: ignore diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_configurations_operations.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_configurations_operations.py index 12a83d42a93bf..ffcef0e95d234 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_configurations_operations.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_configurations_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -5,94 +6,228 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING -import warnings - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload +from urllib.parse import parse_qs, urljoin, urlparse + +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 HttpRequest, HttpResponse +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 MixinABC, _convert_request, _format_url_section + +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 = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/configurations") + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_create_in_subscription_request( + configuration_name: Union[str, "_models.ConfigurationName"], subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/configurations/{configurationName}" + ) # pylint: disable=line-too-long + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "configurationName": _SERIALIZER.url("configuration_name", configuration_name, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_list_by_resource_group_request(resource_group: str, subscription_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Advisor/configurations", + ) # pylint: disable=line-too-long + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroup": _SERIALIZER.url("resource_group", resource_group, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # 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) + -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from typing import Any, Callable, Dict, Generic, Iterable, Optional, TypeVar, Union +def build_create_in_resource_group_request( + configuration_name: Union[str, "_models.ConfigurationName"], + resource_group: str, + subscription_id: str, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - T = TypeVar('T') - ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") -class ConfigurationsOperations(object): - """ConfigurationsOperations operations. + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Advisor/configurations/{configurationName}", + ) # pylint: disable=line-too-long + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "configurationName": _SERIALIZER.url("configuration_name", configuration_name, "str"), + "resourceGroup": _SERIALIZER.url("resource_group", resource_group, "str"), + } - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. + _url = _format_url_section(_url, **path_format_arguments) - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.mgmt.advisor.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + # 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) + + +class ConfigurationsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.advisor.AdvisorManagementClient`'s + :attr:`configurations` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer): - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config + 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") - def list_by_subscription( - self, - **kwargs # type: Any - ): - # type: (...) -> Iterable["_models.ConfigurationListResult"] + @distributed_trace + def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.ConfigData"]: """Retrieve Azure Advisor configurations. Retrieve Azure Advisor configurations and also retrieve configurations of contained resource groups. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ConfigurationListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.advisor.models.ConfigurationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ConfigData or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.advisor.models.ConfigData] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ConfigurationListResult"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConfigurationListResult] + error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list_by_subscription.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + + 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) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] - request = self._client.get(url, query_parameters, header_parameters) + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + request.method = "GET" return request def extract_data(pipeline_response): - deserialized = self._deserialize('ConfigurationListResult', pipeline_response) + deserialized = self._deserialize("ConfigurationListResult", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -101,139 +236,215 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: - error = self._deserialize(_models.ArmErrorResponse, response) map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, 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.Advisor/configurations'} # type: ignore + return ItemPaged(get_next, extract_data) + + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/configurations"} # type: ignore + @overload def create_in_subscription( self, - configuration_name, # type: Union[str, "_models.ConfigurationName"] - config_contract, # type: "_models.ConfigData" - **kwargs # type: Any - ): - # type: (...) -> "_models.ConfigData" + configuration_name: Union[str, "_models.ConfigurationName"], + config_contract: _models.ConfigData, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.ConfigData: """Create/Overwrite Azure Advisor configuration. Create/Overwrite Azure Advisor configuration and also delete all configurations of contained resource groups. - :param configuration_name: Advisor configuration name. Value must be 'default'. + :param configuration_name: Advisor configuration name. Value must be 'default'. "default" + Required. :type configuration_name: str or ~azure.mgmt.advisor.models.ConfigurationName - :param config_contract: The Azure Advisor configuration data structure. + :param config_contract: The Azure Advisor configuration data structure. Required. :type config_contract: ~azure.mgmt.advisor.models.ConfigData + :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: ConfigData or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.ConfigData + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_in_subscription( + self, + configuration_name: Union[str, "_models.ConfigurationName"], + config_contract: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.ConfigData: + """Create/Overwrite Azure Advisor configuration. + + Create/Overwrite Azure Advisor configuration and also delete all configurations of contained + resource groups. + + :param configuration_name: Advisor configuration name. Value must be 'default'. "default" + Required. + :type configuration_name: str or ~azure.mgmt.advisor.models.ConfigurationName + :param config_contract: The Azure Advisor configuration data structure. Required. + :type config_contract: 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: ConfigData or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.ConfigData + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_in_subscription( + self, + configuration_name: Union[str, "_models.ConfigurationName"], + config_contract: Union[_models.ConfigData, IO], + **kwargs: Any + ) -> _models.ConfigData: + """Create/Overwrite Azure Advisor configuration. + + Create/Overwrite Azure Advisor configuration and also delete all configurations of contained + resource groups. + + :param configuration_name: Advisor configuration name. Value must be 'default'. "default" + Required. + :type configuration_name: str or ~azure.mgmt.advisor.models.ConfigurationName + :param config_contract: The Azure Advisor configuration data structure. Is either a model type + or a IO type. Required. + :type config_contract: ~azure.mgmt.advisor.models.ConfigData 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: ConfigData, or the result of cls(response) + :return: ConfigData or the result of cls(response) :rtype: ~azure.mgmt.advisor.models.ConfigData - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ConfigData"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" - - # Construct URL - url = self.create_in_subscription.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - 'configurationName': self._serialize.url("configuration_name", configuration_name, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(config_contract, 'ConfigData') - body_content_kwargs['content'] = body_content - request = self._client.put(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConfigData] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(config_contract, (IO, bytes)): + _content = config_contract + else: + _json = self._serialize.body(config_contract, "ConfigData") + + request = build_create_in_subscription_request( + configuration_name=configuration_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.create_in_subscription.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = 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(_models.ArmErrorResponse, response) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('ConfigData', pipeline_response) + deserialized = self._deserialize("ConfigData", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_in_subscription.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/configurations/{configurationName}'} # type: ignore - def list_by_resource_group( - self, - resource_group, # type: str - **kwargs # type: Any - ): - # type: (...) -> Iterable["_models.ConfigurationListResult"] + create_in_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/configurations/{configurationName}"} # type: ignore + + @distributed_trace + def list_by_resource_group(self, resource_group: str, **kwargs: Any) -> Iterable["_models.ConfigData"]: """Retrieve Azure Advisor configurations. Retrieve Azure Advisor configurations. - :param resource_group: The name of the Azure resource group. + :param resource_group: The name of the Azure resource group. Required. :type resource_group: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ConfigurationListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.advisor.models.ConfigurationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ConfigData or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.advisor.models.ConfigData] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ConfigurationListResult"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConfigurationListResult] + error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list_by_resource_group.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - 'resourceGroup': self._serialize.url("resource_group", resource_group, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + + request = build_list_by_resource_group_request( + resource_group=resource_group, + 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) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] - request = self._client.get(url, query_parameters, header_parameters) + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + request.method = "GET" return request def extract_data(pipeline_response): - deserialized = self._deserialize('ConfigurationListResult', pipeline_response) + deserialized = self._deserialize("ConfigurationListResult", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -242,87 +453,164 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: - error = self._deserialize(_models.ArmErrorResponse, response) map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, 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/{resourceGroup}/providers/Microsoft.Advisor/configurations'} # type: ignore + return ItemPaged(get_next, extract_data) + + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Advisor/configurations"} # type: ignore + @overload def create_in_resource_group( self, - configuration_name, # type: Union[str, "_models.ConfigurationName"] - resource_group, # type: str - config_contract, # type: "_models.ConfigData" - **kwargs # type: Any - ): - # type: (...) -> "_models.ConfigData" + configuration_name: Union[str, "_models.ConfigurationName"], + resource_group: str, + config_contract: _models.ConfigData, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.ConfigData: """Create/Overwrite Azure Advisor configuration. Create/Overwrite Azure Advisor configuration. - :param configuration_name: Advisor configuration name. Value must be 'default'. + :param configuration_name: Advisor configuration name. Value must be 'default'. "default" + Required. :type configuration_name: str or ~azure.mgmt.advisor.models.ConfigurationName - :param resource_group: The name of the Azure resource group. + :param resource_group: The name of the Azure resource group. Required. :type resource_group: str - :param config_contract: The Azure Advisor configuration data structure. + :param config_contract: The Azure Advisor configuration data structure. Required. :type config_contract: ~azure.mgmt.advisor.models.ConfigData + :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: ConfigData, or the result of cls(response) + :return: ConfigData or the result of cls(response) :rtype: ~azure.mgmt.advisor.models.ConfigData - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_in_resource_group( + self, + configuration_name: Union[str, "_models.ConfigurationName"], + resource_group: str, + config_contract: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.ConfigData: + """Create/Overwrite Azure Advisor configuration. + + Create/Overwrite Azure Advisor configuration. + + :param configuration_name: Advisor configuration name. Value must be 'default'. "default" + Required. + :type configuration_name: str or ~azure.mgmt.advisor.models.ConfigurationName + :param resource_group: The name of the Azure resource group. Required. + :type resource_group: str + :param config_contract: The Azure Advisor configuration data structure. Required. + :type config_contract: 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: ConfigData or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.ConfigData + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_in_resource_group( + self, + configuration_name: Union[str, "_models.ConfigurationName"], + resource_group: str, + config_contract: Union[_models.ConfigData, IO], + **kwargs: Any + ) -> _models.ConfigData: + """Create/Overwrite Azure Advisor configuration. + + Create/Overwrite Azure Advisor configuration. + + :param configuration_name: Advisor configuration name. Value must be 'default'. "default" + Required. + :type configuration_name: str or ~azure.mgmt.advisor.models.ConfigurationName + :param resource_group: The name of the Azure resource group. Required. + :type resource_group: str + :param config_contract: The Azure Advisor configuration data structure. Is either a model type + or a IO type. Required. + :type config_contract: ~azure.mgmt.advisor.models.ConfigData 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: ConfigData or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.ConfigData + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ConfigData"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" - - # Construct URL - url = self.create_in_resource_group.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - 'configurationName': self._serialize.url("configuration_name", configuration_name, 'str'), - 'resourceGroup': self._serialize.url("resource_group", resource_group, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(config_contract, 'ConfigData') - body_content_kwargs['content'] = body_content - request = self._client.put(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConfigData] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(config_contract, (IO, bytes)): + _content = config_contract + else: + _json = self._serialize.body(config_contract, "ConfigData") + + request = build_create_in_resource_group_request( + configuration_name=configuration_name, + resource_group=resource_group, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.create_in_resource_group.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = 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(_models.ArmErrorResponse, response) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('ConfigData', pipeline_response) + deserialized = self._deserialize("ConfigData", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_in_resource_group.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Advisor/configurations/{configurationName}'} # type: ignore + + create_in_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Advisor/configurations/{configurationName}"} # type: ignore diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_operations.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_operations.py index f2745798f193e..139b689c28553 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_operations.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -5,87 +6,122 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING -import warnings - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, Iterable, Optional, TypeVar +from urllib.parse import parse_qs, urljoin, urlparse + +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 HttpRequest, HttpResponse +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 MixinABC, _convert_request + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from typing import Any, Callable, Dict, Generic, Iterable, Optional, TypeVar +def build_list_request(**kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - T = TypeVar('T') - ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + accept = _headers.pop("Accept", "application/json") -class Operations(object): - """Operations operations. + # Construct URL + _url = kwargs.pop("template_url", "/providers/Microsoft.Advisor/operations") - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.mgmt.advisor.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +class Operations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.advisor.AdvisorManagementClient`'s + :attr:`operations` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer): - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config - - def list( - self, - **kwargs # type: Any - ): - # type: (...) -> Iterable["_models.OperationEntityListResult"] + 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(self, **kwargs: Any) -> Iterable["_models.OperationEntity"]: """Lists all the available Advisor REST API operations. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationEntityListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.advisor.models.OperationEntityListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either OperationEntity or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.advisor.models.OperationEntity] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.OperationEntityListResult"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationEntityListResult] + error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list.metadata['url'] # type: ignore - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - request = self._client.get(url, query_parameters, header_parameters) + 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) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] - request = self._client.get(url, query_parameters, header_parameters) + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + request.method = "GET" return request def extract_data(pipeline_response): - deserialized = self._deserialize('OperationEntityListResult', pipeline_response) + deserialized = self._deserialize("OperationEntityListResult", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -94,16 +130,18 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, 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.Advisor/operations'} # type: ignore + return ItemPaged(get_next, extract_data) + + list.metadata = {"url": "/providers/Microsoft.Advisor/operations"} # type: ignore diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_patch.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_patch.py new file mode 100644 index 0000000000000..f7dd32510333d --- /dev/null +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_recommendation_metadata_operations.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_recommendation_metadata_operations.py index aa850acf7984d..0fbba1253a295 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_recommendation_metadata_operations.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_recommendation_metadata_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -5,149 +6,209 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING -import warnings - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, Iterable, Optional, TypeVar +from urllib.parse import parse_qs, urljoin, urlparse + +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 HttpRequest, HttpResponse +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 MixinABC, _convert_request, _format_url_section + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_get_request(name: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/providers/Microsoft.Advisor/metadata/{name}") + path_format_arguments = { + "name": _SERIALIZER.url("name", name, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from typing import Any, Callable, Dict, Generic, Iterable, Optional, TypeVar, Union + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - T = TypeVar('T') - ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") -class RecommendationMetadataOperations(object): - """RecommendationMetadataOperations operations. + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.mgmt.advisor.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. +def build_list_request(**kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/providers/Microsoft.Advisor/metadata") + + # 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 RecommendationMetadataOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.advisor.AdvisorManagementClient`'s + :attr:`recommendation_metadata` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer): - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config - - def get( - self, - name, # type: str - **kwargs # type: Any - ): - # type: (...) -> Union["_models.MetadataEntity", "_models.ARMErrorResponseBody"] + 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 get(self, name: str, **kwargs: Any) -> _models.MetadataEntity: """Gets the metadata entity. Gets the metadata entity. - :param name: Name of metadata entity. + :param name: Name of metadata entity. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: MetadataEntity or ARMErrorResponseBody, or the result of cls(response) - :rtype: ~azure.mgmt.advisor.models.MetadataEntity or ~azure.mgmt.advisor.models.ARMErrorResponseBody - :raises: ~azure.core.exceptions.HttpResponseError + :return: MetadataEntity or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.MetadataEntity + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[Union["_models.MetadataEntity", "_models.ARMErrorResponseBody"]] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + 404: lambda response: ResourceNotFoundError( + response=response, + model=self._deserialize(_models.ARMErrorResponseBody, response), + error_format=ARMErrorFormat, + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" - - # Construct URL - url = self.get.metadata['url'] # type: ignore - path_format_arguments = { - 'name': self._serialize.url("name", name, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MetadataEntity] - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + request = build_get_request( + name=name, + 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) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.get(url, query_parameters, header_parameters) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response - if response.status_code not in [200, 404]: + if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize('MetadataEntity', pipeline_response) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - if response.status_code == 404: - deserialized = self._deserialize('ARMErrorResponseBody', pipeline_response) + deserialized = self._deserialize("MetadataEntity", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': '/providers/Microsoft.Advisor/metadata/{name}'} # type: ignore - def list( - self, - **kwargs # type: Any - ): - # type: (...) -> Iterable["_models.MetadataEntityListResult"] + get.metadata = {"url": "/providers/Microsoft.Advisor/metadata/{name}"} # type: ignore + + @distributed_trace + def list(self, **kwargs: Any) -> Iterable["_models.MetadataEntity"]: """Gets the list of metadata entities. Gets the list of metadata entities. :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either MetadataEntityListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.advisor.models.MetadataEntityListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either MetadataEntity or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.advisor.models.MetadataEntity] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.MetadataEntityListResult"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.MetadataEntityListResult] + error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list.metadata['url'] # type: ignore - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - request = self._client.get(url, query_parameters, header_parameters) + 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) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] - request = self._client.get(url, query_parameters, header_parameters) + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + request.method = "GET" return request def extract_data(pipeline_response): - deserialized = self._deserialize('MetadataEntityListResult', pipeline_response) + deserialized = self._deserialize("MetadataEntityListResult", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -156,16 +217,18 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, 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.Advisor/metadata'} # type: ignore + return ItemPaged(get_next, extract_data) + + list.metadata = {"url": "/providers/Microsoft.Advisor/metadata"} # type: ignore diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_recommendations_operations.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_recommendations_operations.py index 13b4cf0fba58c..a3bca43221a5e 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_recommendations_operations.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_recommendations_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -5,216 +6,350 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING -import warnings - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, Iterable, Optional, TypeVar +from urllib.parse import parse_qs, urljoin, urlparse + +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 HttpRequest, HttpResponse +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 MixinABC, _convert_request, _format_url_section + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_generate_request(subscription_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/generateRecommendations" + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_get_generate_status_request(operation_id: str, subscription_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/generateRecommendations/{operationId}", + ) # pylint: disable=line-too-long + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "operationId": _SERIALIZER.url("operation_id", operation_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_list_request( + subscription_id: str, + *, + filter: Optional[str] = None, + top: Optional[int] = None, + skip_token: Optional[str] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/recommendations") + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + if filter is not None: + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") + if top is not None: + _params["$top"] = _SERIALIZER.query("top", top, "int") + if skip_token is not None: + _params["$skipToken"] = _SERIALIZER.query("skip_token", skip_token, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_get_request(resource_uri: str, recommendation_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from typing import Any, Callable, Dict, Generic, Iterable, Optional, TypeVar + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + accept = _headers.pop("Accept", "application/json") - T = TypeVar('T') - ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + # Construct URL + _url = kwargs.pop("template_url", "/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}") + path_format_arguments = { + "resourceUri": _SERIALIZER.url("resource_uri", resource_uri, "str"), + "recommendationId": _SERIALIZER.url("recommendation_id", recommendation_id, "str"), + } -class RecommendationsOperations(object): - """RecommendationsOperations operations. + _url = _format_url_section(_url, **path_format_arguments) - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.mgmt.advisor.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +class RecommendationsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.advisor.AdvisorManagementClient`'s + :attr:`recommendations` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer): - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config - - def generate( - self, - **kwargs # type: Any - ): - # type: (...) -> None + 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 generate(self, **kwargs: Any) -> None: # pylint: disable=inconsistent-return-statements """Initiates the recommendation generation or computation process for a subscription. This operation is asynchronous. The generated recommendations are stored in a cache in the Advisor service. :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" + error_map.update(kwargs.pop("error_map", {}) or {}) - # Construct URL - url = self.generate.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - # Construct headers - header_parameters = {} # type: Dict[str, Any] + request = build_generate_request( + subscription_id=self._config.subscription_id, + api_version=api_version, + template_url=self.generate.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.post(url, query_parameters, header_parameters) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - response_headers['Retry-After']=self._deserialize('str', response.headers.get('Retry-After')) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("str", response.headers.get("Retry-After")) if cls: return cls(pipeline_response, None, response_headers) - generate.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/generateRecommendations'} # type: ignore + generate.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/generateRecommendations"} # type: ignore - def get_generate_status( - self, - operation_id, # type: str - **kwargs # type: Any - ): - # type: (...) -> None + @distributed_trace + def get_generate_status( # pylint: disable=inconsistent-return-statements + self, operation_id: str, **kwargs: Any + ) -> None: """Retrieves the status of the recommendation computation or generation process. Invoke this API after calling the generation recommendation. The URI of this API is returned in the Location field of the response header. :param operation_id: The operation ID, which can be found from the Location field in the - generate recommendation response header. + generate recommendation response header. Required. :type operation_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - - # Construct URL - url = self.get_generate_status.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - 'operationId': self._serialize.url("operation_id", operation_id, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - # Construct headers - header_parameters = {} # type: Dict[str, Any] + request = build_get_generate_status_request( + operation_id=operation_id, + subscription_id=self._config.subscription_id, + api_version=api_version, + template_url=self.get_generate_status.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.get(url, query_parameters, header_parameters) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [202, 204]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - get_generate_status.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/generateRecommendations/{operationId}'} # type: ignore + get_generate_status.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/generateRecommendations/{operationId}"} # type: ignore + @distributed_trace def list( - self, - filter=None, # type: Optional[str] - top=None, # type: Optional[int] - skip_token=None, # type: Optional[str] - **kwargs # type: Any - ): - # type: (...) -> Iterable["_models.ResourceRecommendationBaseListResult"] + self, filter: Optional[str] = None, top: Optional[int] = None, skip_token: Optional[str] = None, **kwargs: Any + ) -> Iterable["_models.ResourceRecommendationBase"]: """Obtains cached recommendations for a subscription. The recommendations are generated or computed by invoking generateRecommendations. :param filter: The filter to apply to the recommendations.:code:`
`Filter can be applied to properties ['ResourceId', 'ResourceGroup', 'RecommendationTypeGuid', '\ `Category <#category>`_\ '] with operators ['eq', 'and', 'or'].:code:`
`Example::code:`
`- - $filter=Category eq 'Cost' and ResourceGroup eq 'MyResourceGroup'. + $filter=Category eq 'Cost' and ResourceGroup eq 'MyResourceGroup'. Default value is None. :type filter: str :param top: The number of recommendations per page if a paged version of this API is being - used. + used. Default value is None. :type top: int - :param skip_token: The page-continuation token to use with a paged version of this API. + :param skip_token: The page-continuation token to use with a paged version of this API. Default + value is None. :type skip_token: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ResourceRecommendationBaseListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.advisor.models.ResourceRecommendationBaseListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ResourceRecommendationBase or the result of + cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.advisor.models.ResourceRecommendationBase] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ResourceRecommendationBaseListResult"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceRecommendationBaseListResult] + error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - if filter is not None: - query_parameters['$filter'] = self._serialize.query("filter", filter, 'str') - if top is not None: - query_parameters['$top'] = self._serialize.query("top", top, 'int') - if skip_token is not None: - query_parameters['$skipToken'] = self._serialize.query("skip_token", skip_token, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + + request = build_list_request( + subscription_id=self._config.subscription_id, + filter=filter, + top=top, + skip_token=skip_token, + 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) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] - request = self._client.get(url, query_parameters, header_parameters) + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + request.method = "GET" return request def extract_data(pipeline_response): - deserialized = self._deserialize('ResourceRecommendationBaseListResult', pipeline_response) + deserialized = self._deserialize("ResourceRecommendationBaseListResult", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -223,75 +358,77 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) return pipeline_response - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/recommendations'} # type: ignore - - def get( - self, - resource_uri, # type: str - recommendation_id, # type: str - **kwargs # type: Any - ): - # type: (...) -> "_models.ResourceRecommendationBase" + return ItemPaged(get_next, extract_data) + + list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/recommendations"} # type: ignore + + @distributed_trace + def get(self, resource_uri: str, recommendation_id: str, **kwargs: Any) -> _models.ResourceRecommendationBase: """Obtains details of a cached recommendation. :param resource_uri: The fully qualified Azure Resource Manager identifier of the resource to - which the recommendation applies. + which the recommendation applies. Required. :type resource_uri: str - :param recommendation_id: The recommendation ID. + :param recommendation_id: The recommendation ID. Required. :type recommendation_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ResourceRecommendationBase, or the result of cls(response) + :return: ResourceRecommendationBase or the result of cls(response) :rtype: ~azure.mgmt.advisor.models.ResourceRecommendationBase - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ResourceRecommendationBase"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" - - # Construct URL - url = self.get.metadata['url'] # type: ignore - path_format_arguments = { - 'resourceUri': self._serialize.url("resource_uri", resource_uri, 'str'), - 'recommendationId': self._serialize.url("recommendation_id", recommendation_id, 'str'), + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - url = self._client.format_url(url, **path_format_arguments) + error_map.update(kwargs.pop("error_map", {}) or {}) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ResourceRecommendationBase] + + request = build_get_request( + resource_uri=resource_uri, + recommendation_id=recommendation_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) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.get(url, query_parameters, header_parameters) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('ResourceRecommendationBase', pipeline_response) + deserialized = self._deserialize("ResourceRecommendationBase", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': '/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}'} # type: ignore + + get.metadata = {"url": "/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}"} # type: ignore diff --git a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_suppressions_operations.py b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_suppressions_operations.py index e6264f43763b3..665cc728a3952 100644 --- a/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_suppressions_operations.py +++ b/sdk/advisor/azure-mgmt-advisor/azure/mgmt/advisor/operations/_suppressions_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -5,306 +6,523 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING -import warnings - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload +from urllib.parse import parse_qs, urljoin, urlparse + +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 HttpRequest, HttpResponse +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 MixinABC, _convert_request, _format_url_section + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_get_request(resource_uri: str, recommendation_id: str, name: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}/suppressions/{name}", + ) # pylint: disable=line-too-long + path_format_arguments = { + "resourceUri": _SERIALIZER.url("resource_uri", resource_uri, "str"), + "recommendationId": _SERIALIZER.url("recommendation_id", recommendation_id, "str"), + "name": _SERIALIZER.url("name", name, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_create_request(resource_uri: str, recommendation_id: str, name: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}/suppressions/{name}", + ) # pylint: disable=line-too-long + path_format_arguments = { + "resourceUri": _SERIALIZER.url("resource_uri", resource_uri, "str"), + "recommendationId": _SERIALIZER.url("recommendation_id", recommendation_id, "str"), + "name": _SERIALIZER.url("name", name, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # 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_uri: str, recommendation_id: str, name: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}/suppressions/{name}", + ) # pylint: disable=line-too-long + path_format_arguments = { + "resourceUri": _SERIALIZER.url("resource_uri", resource_uri, "str"), + "recommendationId": _SERIALIZER.url("recommendation_id", recommendation_id, "str"), + "name": _SERIALIZER.url("name", name, "str"), + } -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from typing import Any, Callable, Dict, Generic, Iterable, Optional, TypeVar, Union + _url = _format_url_section(_url, **path_format_arguments) - T = TypeVar('T') - ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") -class SuppressionsOperations(object): - """SuppressionsOperations operations. + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.mgmt.advisor.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + +def build_list_request( + subscription_id: str, *, top: Optional[int] = None, skip_token: Optional[str] = None, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-09-01")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/suppressions") + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + if top is not None: + _params["$top"] = _SERIALIZER.query("top", top, "int") + if skip_token is not None: + _params["$skipToken"] = _SERIALIZER.query("skip_token", skip_token, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +class SuppressionsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.advisor.AdvisorManagementClient`'s + :attr:`suppressions` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer): - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config + 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") - def get( - self, - resource_uri, # type: str - recommendation_id, # type: str - name, # type: str - **kwargs # type: Any - ): - # type: (...) -> Union["_models.SuppressionContract", "_models.ArmErrorResponse"] + @distributed_trace + def get(self, resource_uri: str, recommendation_id: str, name: str, **kwargs: Any) -> _models.SuppressionContract: """Obtains the details of a suppression. :param resource_uri: The fully qualified Azure Resource Manager identifier of the resource to - which the recommendation applies. + which the recommendation applies. Required. :type resource_uri: str - :param recommendation_id: The recommendation ID. + :param recommendation_id: The recommendation ID. Required. :type recommendation_id: str - :param name: The name of the suppression. + :param name: The name of the suppression. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SuppressionContract or ArmErrorResponse, or the result of cls(response) - :rtype: ~azure.mgmt.advisor.models.SuppressionContract or ~azure.mgmt.advisor.models.ArmErrorResponse - :raises: ~azure.core.exceptions.HttpResponseError + :return: SuppressionContract or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.SuppressionContract + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[Union["_models.SuppressionContract", "_models.ArmErrorResponse"]] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" - - # Construct URL - url = self.get.metadata['url'] # type: ignore - path_format_arguments = { - 'resourceUri': self._serialize.url("resource_uri", resource_uri, 'str'), - 'recommendationId': self._serialize.url("recommendation_id", recommendation_id, 'str'), - 'name': self._serialize.url("name", name, 'str'), + 401: ClientAuthenticationError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + 404: lambda response: ResourceNotFoundError( + response=response, + model=self._deserialize(_models.ArmErrorResponse, response), + error_format=ARMErrorFormat, + ), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SuppressionContract] + + request = build_get_request( + resource_uri=resource_uri, + recommendation_id=recommendation_id, + name=name, + 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) # type: ignore - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.get(url, query_parameters, header_parameters) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response - if response.status_code not in [200, 404]: + if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize('SuppressionContract', pipeline_response) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - if response.status_code == 404: - deserialized = self._deserialize('ArmErrorResponse', pipeline_response) + deserialized = self._deserialize("SuppressionContract", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': '/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}/suppressions/{name}'} # type: ignore + get.metadata = {"url": "/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}/suppressions/{name}"} # type: ignore + + @overload def create( self, - resource_uri, # type: str - recommendation_id, # type: str - name, # type: str - suppression_contract, # type: "_models.SuppressionContract" - **kwargs # type: Any - ): - # type: (...) -> Union["_models.SuppressionContract", "_models.ArmErrorResponse"] + resource_uri: str, + recommendation_id: str, + name: str, + suppression_contract: _models.SuppressionContract, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SuppressionContract: """Enables the snoozed or dismissed attribute of a recommendation. The snoozed or dismissed attribute is referred to as a suppression. Use this API to create or update the snoozed or dismissed status of a recommendation. :param resource_uri: The fully qualified Azure Resource Manager identifier of the resource to - which the recommendation applies. + which the recommendation applies. Required. :type resource_uri: str - :param recommendation_id: The recommendation ID. + :param recommendation_id: The recommendation ID. Required. :type recommendation_id: str - :param name: The name of the suppression. + :param name: The name of the suppression. Required. :type name: str :param suppression_contract: The snoozed or dismissed attribute; for example, the snooze - duration. + duration. Required. :type suppression_contract: ~azure.mgmt.advisor.models.SuppressionContract + :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: SuppressionContract or ArmErrorResponse, or the result of cls(response) - :rtype: ~azure.mgmt.advisor.models.SuppressionContract or ~azure.mgmt.advisor.models.ArmErrorResponse - :raises: ~azure.core.exceptions.HttpResponseError + :return: SuppressionContract or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.SuppressionContract + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create( + self, + resource_uri: str, + recommendation_id: str, + name: str, + suppression_contract: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SuppressionContract: + """Enables the snoozed or dismissed attribute of a recommendation. The snoozed or dismissed + attribute is referred to as a suppression. Use this API to create or update the snoozed or + dismissed status of a recommendation. + + :param resource_uri: The fully qualified Azure Resource Manager identifier of the resource to + which the recommendation applies. Required. + :type resource_uri: str + :param recommendation_id: The recommendation ID. Required. + :type recommendation_id: str + :param name: The name of the suppression. Required. + :type name: str + :param suppression_contract: The snoozed or dismissed attribute; for example, the snooze + duration. Required. + :type suppression_contract: 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: SuppressionContract or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.SuppressionContract + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create( + self, + resource_uri: str, + recommendation_id: str, + name: str, + suppression_contract: Union[_models.SuppressionContract, IO], + **kwargs: Any + ) -> _models.SuppressionContract: + """Enables the snoozed or dismissed attribute of a recommendation. The snoozed or dismissed + attribute is referred to as a suppression. Use this API to create or update the snoozed or + dismissed status of a recommendation. + + :param resource_uri: The fully qualified Azure Resource Manager identifier of the resource to + which the recommendation applies. Required. + :type resource_uri: str + :param recommendation_id: The recommendation ID. Required. + :type recommendation_id: str + :param name: The name of the suppression. Required. + :type name: str + :param suppression_contract: The snoozed or dismissed attribute; for example, the snooze + duration. Is either a model type or a IO type. Required. + :type suppression_contract: ~azure.mgmt.advisor.models.SuppressionContract 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: SuppressionContract or the result of cls(response) + :rtype: ~azure.mgmt.advisor.models.SuppressionContract + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[Union["_models.SuppressionContract", "_models.ArmErrorResponse"]] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" - - # Construct URL - url = self.create.metadata['url'] # type: ignore - path_format_arguments = { - 'resourceUri': self._serialize.url("resource_uri", resource_uri, 'str'), - 'recommendationId': self._serialize.url("recommendation_id", recommendation_id, 'str'), - 'name': self._serialize.url("name", name, 'str'), + 401: ClientAuthenticationError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + 404: lambda response: ResourceNotFoundError( + response=response, + model=self._deserialize(_models.ArmErrorResponse, response), + error_format=ARMErrorFormat, + ), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(suppression_contract, 'SuppressionContract') - body_content_kwargs['content'] = body_content - request = self._client.put(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.SuppressionContract] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(suppression_contract, (IO, bytes)): + _content = suppression_contract + else: + _json = self._serialize.body(suppression_contract, "SuppressionContract") + + request = build_create_request( + resource_uri=resource_uri, + recommendation_id=recommendation_id, + name=name, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.create.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response - if response.status_code not in [200, 404]: + if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - if response.status_code == 200: - deserialized = self._deserialize('SuppressionContract', pipeline_response) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - if response.status_code == 404: - deserialized = self._deserialize('ArmErrorResponse', pipeline_response) + deserialized = self._deserialize("SuppressionContract", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': '/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}/suppressions/{name}'} # type: ignore - def delete( - self, - resource_uri, # type: str - recommendation_id, # type: str - name, # type: str - **kwargs # type: Any - ): - # type: (...) -> None + create.metadata = {"url": "/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}/suppressions/{name}"} # type: ignore + + @distributed_trace + def delete( # pylint: disable=inconsistent-return-statements + self, resource_uri: str, recommendation_id: str, name: str, **kwargs: Any + ) -> None: """Enables the activation of a snoozed or dismissed recommendation. The snoozed or dismissed attribute of a recommendation is referred to as a suppression. :param resource_uri: The fully qualified Azure Resource Manager identifier of the resource to - which the recommendation applies. + which the recommendation applies. Required. :type resource_uri: str - :param recommendation_id: The recommendation ID. + :param recommendation_id: The recommendation ID. Required. :type recommendation_id: str - :param name: The name of the suppression. + :param name: The name of the suppression. Required. :type name: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - - # Construct URL - url = self.delete.metadata['url'] # type: ignore - path_format_arguments = { - 'resourceUri': self._serialize.url("resource_uri", resource_uri, 'str'), - 'recommendationId': self._serialize.url("recommendation_id", recommendation_id, 'str'), - 'name': self._serialize.url("name", name, 'str'), + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + + request = build_delete_request( + resource_uri=resource_uri, + recommendation_id=recommendation_id, + name=name, + 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) # type: ignore - # Construct headers - header_parameters = {} # type: Dict[str, Any] + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.delete(url, query_parameters, header_parameters) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': '/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}/suppressions/{name}'} # type: ignore + delete.metadata = {"url": "/{resourceUri}/providers/Microsoft.Advisor/recommendations/{recommendationId}/suppressions/{name}"} # type: ignore + @distributed_trace def list( - self, - top=None, # type: Optional[int] - skip_token=None, # type: Optional[str] - **kwargs # type: Any - ): - # type: (...) -> Iterable["_models.SuppressionContractListResult"] + self, top: Optional[int] = None, skip_token: Optional[str] = None, **kwargs: Any + ) -> Iterable["_models.SuppressionContract"]: """Retrieves the list of snoozed or dismissed suppressions for a subscription. The snoozed or dismissed attribute of a recommendation is referred to as a suppression. :param top: The number of suppressions per page if a paged version of this API is being used. + Default value is None. :type top: int - :param skip_token: The page-continuation token to use with a paged version of this API. + :param skip_token: The page-continuation token to use with a paged version of this API. Default + value is None. :type skip_token: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SuppressionContractListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.advisor.models.SuppressionContractListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either SuppressionContract or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.advisor.models.SuppressionContract] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.SuppressionContractListResult"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SuppressionContractListResult] + error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2020-01-01" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list.metadata['url'] # type: ignore - path_format_arguments = { - 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), - } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - if top is not None: - query_parameters['$top'] = self._serialize.query("top", top, 'int') - if skip_token is not None: - query_parameters['$skipToken'] = self._serialize.query("skip_token", skip_token, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + + request = build_list_request( + subscription_id=self._config.subscription_id, + top=top, + skip_token=skip_token, + 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) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] - request = self._client.get(url, query_parameters, header_parameters) + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + request.method = "GET" return request def extract_data(pipeline_response): - deserialized = self._deserialize('SuppressionContractListResult', pipeline_response) + deserialized = self._deserialize("SuppressionContractListResult", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -313,16 +531,18 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ArmErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) return pipeline_response - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/suppressions'} # type: ignore + return ItemPaged(get_next, extract_data) + + list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Advisor/suppressions"} # type: ignore