From 8b65914dbb6c5b48bc8ee8cc3dbf584ef070502e Mon Sep 17 00:00:00 2001 From: SDKAuto Date: Mon, 14 Apr 2025 01:54:54 +0000 Subject: [PATCH] CodeGen from PR 33785 in Azure/azure-rest-api-specs Merge c2c8e25ff34780169779ffadfcc061acd364fe20 into d18ba009da04dd6afc04402c39f87e032051fe9b --- .../azure-mgmt-subscription/CHANGELOG.md | 21 + .../azure-mgmt-subscription/README.md | 16 +- .../azure-mgmt-subscription/_meta.json | 10 +- .../azure/mgmt/subscription/__init__.py | 12 +- .../azure/mgmt/subscription/_configuration.py | 8 +- .../azure/mgmt/subscription/_patch.py | 1 + .../azure/mgmt/subscription/_serialization.py | 611 +++++++++++------- .../mgmt/subscription/_subscription_client.py | 39 +- .../azure/mgmt/subscription/_vendor.py | 27 - .../azure/mgmt/subscription/_version.py | 2 +- .../azure/mgmt/subscription/aio/__init__.py | 12 +- .../mgmt/subscription/aio/_configuration.py | 8 +- .../azure/mgmt/subscription/aio/_patch.py | 1 + .../subscription/aio/_subscription_client.py | 41 +- .../subscription/aio/operations/__init__.py | 26 +- .../aio/operations/_alias_operations.py | 166 ++--- .../operations/_billing_account_operations.py | 35 +- .../aio/operations/_operations.py | 38 +- .../_subscription_operation_operations.py | 112 ++++ .../operations/_subscription_operations.py | 212 +++--- .../_subscription_policy_operations.py | 100 ++- .../operations/_subscriptions_operations.py | 87 +-- .../aio/operations/_tenants_operations.py | 38 +- .../mgmt/subscription/models/__init__.py | 97 +-- .../mgmt/subscription/models/_models_py3.py | 143 ++-- .../mgmt/subscription/operations/__init__.py | 26 +- .../operations/_alias_operations.py | 178 ++--- .../operations/_billing_account_operations.py | 39 +- .../subscription/operations/_operations.py | 40 +- .../_subscription_operation_operations.py | 139 ++++ .../operations/_subscription_operations.py | 232 +++---- .../_subscription_policy_operations.py | 108 ++-- .../operations/_subscriptions_operations.py | 97 ++- .../operations/_tenants_operations.py | 40 +- .../accept_ownership_status.py | 1 + .../accept_subscription_ownership.py | 4 +- .../generated_samples/cancel_subscription.py | 1 + .../generated_samples/change_tenant_policy.py | 1 + .../generated_samples/create_alias.py | 1 + .../generated_samples/delete_alias.py | 4 +- .../generated_samples/enable_subscription.py | 1 + .../generated_samples/get_alias.py | 1 + .../get_billing_account_policy.py | 1 + .../generated_samples/get_operations.py | 1 + .../generated_samples/get_subscription.py | 1 + .../get_subscription_operation.py | 40 ++ .../generated_samples/get_tenant_policy.py | 1 + .../get_tenant_policy_list.py | 1 + .../generated_samples/list_alias.py | 1 + .../generated_samples/list_locations.py | 1 + .../generated_samples/list_subscriptions.py | 1 + .../generated_samples/list_tenants.py | 1 + .../generated_samples/rename_subscription.py | 1 + .../generated_tests/conftest.py | 35 + .../test_subscription_alias_operations.py | 71 ++ ...est_subscription_alias_operations_async.py | 74 +++ ...subscription_billing_account_operations.py | 30 + ...iption_billing_account_operations_async.py | 31 + .../test_subscription_operations.py | 29 + .../test_subscription_operations_async.py | 30 + ...ption_subscription_operation_operations.py | 30 + ...subscription_operation_operations_async.py | 31 + ...st_subscription_subscription_operations.py | 76 +++ ...scription_subscription_operations_async.py | 79 +++ ...cription_subscription_policy_operations.py | 54 ++ ...on_subscription_policy_operations_async.py | 55 ++ ...t_subscription_subscriptions_operations.py | 51 ++ ...cription_subscriptions_operations_async.py | 52 ++ .../test_subscription_tenants_operations.py | 29 + ...t_subscription_tenants_operations_async.py | 30 + .../sdk_packaging.toml | 2 +- .../azure-mgmt-subscription/setup.py | 86 +-- 72 files changed, 2385 insertions(+), 1316 deletions(-) delete mode 100644 sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_vendor.py create mode 100644 sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscription_operation_operations.py create mode 100644 sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscription_operation_operations.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_samples/get_subscription_operation.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/conftest.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_alias_operations.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_alias_operations_async.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_billing_account_operations.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_billing_account_operations_async.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_operations.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_operations_async.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operation_operations.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operation_operations_async.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operations.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operations_async.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_policy_operations.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_policy_operations_async.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscriptions_operations.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscriptions_operations_async.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_tenants_operations.py create mode 100644 sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_tenants_operations_async.py diff --git a/sdk/subscription/azure-mgmt-subscription/CHANGELOG.md b/sdk/subscription/azure-mgmt-subscription/CHANGELOG.md index 49ef6cd3623c..70ee456822d6 100644 --- a/sdk/subscription/azure-mgmt-subscription/CHANGELOG.md +++ b/sdk/subscription/azure-mgmt-subscription/CHANGELOG.md @@ -1,5 +1,26 @@ # Release History +## 3.2.0 (2025-04-14) + +### Features Added + + - Client `SubscriptionClient` added operation group `subscription_operation` + - Model `Subscription` added property `tenant_id` + - Model `Subscription` added property `tags` + - Model `TenantIdDescription` added property `tenant_category` + - Model `TenantIdDescription` added property `country` + - Model `TenantIdDescription` added property `country_code` + - Model `TenantIdDescription` added property `display_name` + - Model `TenantIdDescription` added property `domains` + - Model `TenantIdDescription` added property `default_domain` + - Model `TenantIdDescription` added property `tenant_type` + - Added model `SubscriptionCreationResult` + - Added model `SubscriptionOperationOperations` + - Method `AliasOperations.begin_create` has a new overload `def begin_create(self: None, alias_name: str, body: IO[bytes], content_type: str)` + - Method `SubscriptionOperations.begin_accept_ownership` has a new overload `def begin_accept_ownership(self: None, subscription_id: str, body: IO[bytes], content_type: str)` + - Method `SubscriptionOperations.rename` has a new overload `def rename(self: None, subscription_id: str, body: IO[bytes], content_type: str)` + - Method `SubscriptionPolicyOperations.add_update_policy_for_tenant` has a new overload `def add_update_policy_for_tenant(self: None, body: IO[bytes], content_type: str)` + ## 3.2.0b1 (2022-12-27) ### Features Added diff --git a/sdk/subscription/azure-mgmt-subscription/README.md b/sdk/subscription/azure-mgmt-subscription/README.md index 7ac842370f0a..249c984f5b8a 100644 --- a/sdk/subscription/azure-mgmt-subscription/README.md +++ b/sdk/subscription/azure-mgmt-subscription/README.md @@ -1,7 +1,7 @@ # Microsoft Azure SDK for Python This is the Microsoft Azure Subscription Management Client Library. -This package has been tested with Python 3.7+. +This package has been tested with Python 3.8+. For a more complete view of Azure libraries, see the [azure sdk python release](https://aka.ms/azsdk/python/all). ## _Disclaimer_ @@ -12,7 +12,7 @@ _Azure SDK Python packages support for Python 2.7 has ended 01 January 2022. For ### Prerequisites -- Python 3.7+ is required to use this package. +- Python 3.8+ is required to use this package. - [Azure subscription](https://azure.microsoft.com/free/) ### Install the package @@ -24,11 +24,11 @@ pip install azure-identity ### Authentication -By default, [Azure Active Directory](https://aka.ms/awps/aad) token authentication depends on correct configure of following environment variables. +By default, [Azure Active Directory](https://aka.ms/awps/aad) token authentication depends on correct configuration of the following environment variables. - `AZURE_CLIENT_ID` for Azure client ID. - `AZURE_TENANT_ID` for Azure tenant ID. -- `AZURE_CLIENT_SECRET` or `AZURE_CLIENT_CERTIFICATE_PATH` for client secret or client certificate. +- `AZURE_CLIENT_SECRET` for Azure client secret. With above configuration, client can be authenticated by following code: @@ -41,8 +41,9 @@ client = SubscriptionClient(credential=DefaultAzureCredential()) ## Examples - -Code samples for this package can be found at [Subscription Management](https://docs.microsoft.com/samples/browse/?languages=python&term=Getting%20started%20-%20Managing&terms=Getting%20started%20-%20Managing) on docs.microsoft.com and [Samples Repo](https://aka.ms/azsdk/python/mgmt/samples) +Code samples for this package can be found at: +- [Search Subscription Management](https://docs.microsoft.com/samples/browse/?languages=python&term=Getting%20started%20-%20Managing&terms=Getting%20started%20-%20Managing) on docs.microsoft.com +- [Azure Python Mgmt SDK Samples Repo](https://aka.ms/azsdk/python/mgmt/samples) ## Troubleshooting @@ -54,6 +55,3 @@ Code samples for this package can be found at [Subscription Management](https:// If you encounter any bugs or have suggestions, please file an issue in the [Issues](https://github.com/Azure/azure-sdk-for-python/issues) section of the project. - - - diff --git a/sdk/subscription/azure-mgmt-subscription/_meta.json b/sdk/subscription/azure-mgmt-subscription/_meta.json index b7ede82ba78d..8289db484a29 100644 --- a/sdk/subscription/azure-mgmt-subscription/_meta.json +++ b/sdk/subscription/azure-mgmt-subscription/_meta.json @@ -1,11 +1,11 @@ { - "commit": "89a9bf17524904e7670f0fd2d62ac882ca00d85c", + "commit": "78b96ac0a7822252de1713f2b75c3ea5928579af", "repository_url": "https://github.com/Azure/azure-rest-api-specs", - "autorest": "3.9.2", + "autorest": "3.10.2", "use": [ - "@autorest/python@6.2.7", - "@autorest/modelerfour@4.24.3" + "@autorest/python@6.27.4", + "@autorest/modelerfour@4.27.0" ], - "autorest_command": "autorest specification/subscription/resource-manager/readme.md --generate-sample=True --include-x-ms-examples-original-file=True --python --python-sdks-folder=/home/vsts/work/1/azure-sdk-for-python/sdk --use=@autorest/python@6.2.7 --use=@autorest/modelerfour@4.24.3 --version=3.9.2 --version-tolerant=False", + "autorest_command": "autorest specification/subscription/resource-manager/readme.md --generate-sample=True --generate-test=True --include-x-ms-examples-original-file=True --python --python-sdks-folder=/mnt/vss/_work/1/s/azure-sdk-for-python/sdk --use=@autorest/python@6.27.4 --use=@autorest/modelerfour@4.27.0 --version=3.10.2 --version-tolerant=False", "readme": "specification/subscription/resource-manager/readme.md" } \ No newline at end of file diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/__init__.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/__init__.py index 5505b1d16f47..2ce2c3a5dd64 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/__init__.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/__init__.py @@ -5,15 +5,21 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._subscription_client import SubscriptionClient +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._subscription_client import SubscriptionClient # type: ignore from ._version import VERSION __version__ = VERSION try: from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import + from ._patch import * except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk @@ -21,6 +27,6 @@ __all__ = [ "SubscriptionClient", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_configuration.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_configuration.py index eea73aeac395..ba2a3fd5a057 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_configuration.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_configuration.py @@ -8,18 +8,16 @@ from typing import Any, TYPE_CHECKING -from azure.core.configuration import Configuration from azure.core.pipeline import policies from azure.mgmt.core.policies import ARMChallengeAuthenticationPolicy, ARMHttpLoggingPolicy from ._version import VERSION if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials import TokenCredential -class SubscriptionClientConfiguration(Configuration): # pylint: disable=too-many-instance-attributes +class SubscriptionClientConfiguration: # pylint: disable=too-many-instance-attributes """Configuration for SubscriptionClient. Note that all parameters used to create this instance are saved as instance @@ -30,13 +28,13 @@ class SubscriptionClientConfiguration(Configuration): # pylint: disable=too-man """ def __init__(self, credential: "TokenCredential", **kwargs: Any) -> None: - super(SubscriptionClientConfiguration, self).__init__(**kwargs) if credential is None: raise ValueError("Parameter 'credential' must not be None.") self.credential = credential self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) kwargs.setdefault("sdk_moniker", "mgmt-subscription/{}".format(VERSION)) + self.polling_interval = kwargs.get("polling_interval", 30) self._configure(**kwargs) def _configure(self, **kwargs: Any) -> None: @@ -45,9 +43,9 @@ def _configure(self, **kwargs: Any) -> None: self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs) self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs) self.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**kwargs) - self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs) + self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) self.authentication_policy = kwargs.get("authentication_policy") if self.credential and not self.authentication_policy: self.authentication_policy = ARMChallengeAuthenticationPolicy( diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_patch.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_patch.py index f99e77fef986..17dbc073e01b 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_patch.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_patch.py @@ -25,6 +25,7 @@ # # -------------------------------------------------------------------------- + # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_serialization.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_serialization.py index 2c170e28dbca..b24ab2885450 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_serialization.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_serialization.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # -------------------------------------------------------------------------- # # Copyright (c) Microsoft Corporation. All rights reserved. @@ -24,7 +25,6 @@ # # -------------------------------------------------------------------------- -# pylint: skip-file # pyright: reportUnnecessaryTypeIgnoreComment=false from base64 import b64decode, b64encode @@ -38,7 +38,21 @@ import re import sys import codecs -from typing import Optional, Union, AnyStr, IO, Mapping +from typing import ( + Dict, + Any, + cast, + Optional, + Union, + AnyStr, + IO, + Mapping, + Callable, + TypeVar, + MutableMapping, + Type, + List, +) try: from urllib import quote # type: ignore @@ -48,12 +62,14 @@ import isodate # type: ignore -from typing import Dict, Any, cast - -from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback +from azure.core.exceptions import DeserializationError, SerializationError +from azure.core.serialization import NULL as CoreNull _BOM = codecs.BOM_UTF8.decode(encoding="utf-8") +ModelType = TypeVar("ModelType", bound="Model") +JSON = MutableMapping[str, Any] + class RawDeserializer: @@ -74,6 +90,8 @@ def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type: :param data: Input, could be bytes or stream (will be decoded with UTF8) or text :type data: str or bytes or IO :param str content_type: The content type. + :return: The deserialized data. + :rtype: object """ if hasattr(data, "read"): # Assume a stream @@ -95,7 +113,7 @@ def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type: try: return json.loads(data_as_str) except ValueError as err: - raise DeserializationError("JSON is invalid: {}".format(err), err) + raise DeserializationError("JSON is invalid: {}".format(err), err) from err elif "xml" in (content_type or []): try: @@ -107,7 +125,7 @@ def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type: pass return ET.fromstring(data_as_str) # nosec - except ET.ParseError: + except ET.ParseError as err: # It might be because the server has an issue, and returned JSON with # content-type XML.... # So let's try a JSON load, and if it's still broken @@ -126,7 +144,9 @@ def _json_attemp(data): # The function hack is because Py2.7 messes up with exception # context otherwise. _LOGGER.critical("Wasn't XML not JSON, failing") - raise_with_traceback(DeserializationError, "XML is invalid") + raise DeserializationError("XML is invalid") from err + elif content_type.startswith("text/"): + return data_as_str raise DeserializationError("Cannot deserialize content-type: {}".format(content_type)) @classmethod @@ -136,6 +156,11 @@ def deserialize_from_http_generics(cls, body_bytes: Optional[Union[AnyStr, IO]], Use bytes and headers to NOT use any requests/aiohttp or whatever specific implementation. Headers will tested for "content-type" + + :param bytes body_bytes: The body of the response. + :param dict headers: The headers of the response. + :returns: The deserialized data. + :rtype: object """ # Try to use content-type from headers if available content_type = None @@ -153,13 +178,6 @@ def deserialize_from_http_generics(cls, body_bytes: Optional[Union[AnyStr, IO]], return None -try: - basestring # type: ignore - unicode_str = unicode # type: ignore -except NameError: - basestring = str - unicode_str = str - _LOGGER = logging.getLogger(__name__) try: @@ -172,15 +190,30 @@ class UTC(datetime.tzinfo): """Time Zone info for handling UTC""" def utcoffset(self, dt): - """UTF offset for UTC is 0.""" + """UTF offset for UTC is 0. + + :param datetime.datetime dt: The datetime + :returns: The offset + :rtype: datetime.timedelta + """ return datetime.timedelta(0) def tzname(self, dt): - """Timestamp representation.""" + """Timestamp representation. + + :param datetime.datetime dt: The datetime + :returns: The timestamp representation + :rtype: str + """ return "Z" def dst(self, dt): - """No daylight saving for UTC.""" + """No daylight saving for UTC. + + :param datetime.datetime dt: The datetime + :returns: The daylight saving time + :rtype: datetime.timedelta + """ return datetime.timedelta(hours=1) @@ -194,7 +227,7 @@ class _FixedOffset(datetime.tzinfo): # type: ignore :param datetime.timedelta offset: offset in timedelta format """ - def __init__(self, offset): + def __init__(self, offset) -> None: self.__offset = offset def utcoffset(self, dt): @@ -223,24 +256,26 @@ def __getinitargs__(self): _FLATTEN = re.compile(r"(? None: + self.additional_properties: Optional[Dict[str, Any]] = {} + for k in kwargs: # pylint: disable=consider-using-dict-items if k not in self._attribute_map: _LOGGER.warning("%s is not a known attribute of class %s and will be ignored", k, self.__class__) elif k in self._validation and self._validation[k].get("readonly", False): @@ -287,25 +329,35 @@ def __init__(self, **kwargs): else: setattr(self, k, kwargs[k]) - def __eq__(self, other): - """Compare objects by comparing all attributes.""" + def __eq__(self, other: Any) -> bool: + """Compare objects by comparing all attributes. + + :param object other: The object to compare + :returns: True if objects are equal + :rtype: bool + """ if isinstance(other, self.__class__): return self.__dict__ == other.__dict__ return False - def __ne__(self, other): - """Compare objects by comparing all attributes.""" + def __ne__(self, other: Any) -> bool: + """Compare objects by comparing all attributes. + + :param object other: The object to compare + :returns: True if objects are not equal + :rtype: bool + """ return not self.__eq__(other) - def __str__(self): + def __str__(self) -> str: return str(self.__dict__) @classmethod - def enable_additional_properties_sending(cls): + def enable_additional_properties_sending(cls) -> None: cls._attribute_map["additional_properties"] = {"key": "", "type": "{object}"} @classmethod - def is_xml_model(cls): + def is_xml_model(cls) -> bool: try: cls._xml_map # type: ignore except AttributeError: @@ -314,7 +366,11 @@ def is_xml_model(cls): @classmethod def _create_xml_node(cls): - """Create XML node.""" + """Create XML node. + + :returns: The XML node + :rtype: xml.etree.ElementTree.Element + """ try: xml_map = cls._xml_map # type: ignore except AttributeError: @@ -322,8 +378,8 @@ def _create_xml_node(cls): return _create_xml_node(xml_map.get("name", cls.__name__), xml_map.get("prefix", None), xml_map.get("ns", None)) - def serialize(self, keep_readonly=False, **kwargs): - """Return the JSON that would be sent to azure from this model. + def serialize(self, keep_readonly: bool = False, **kwargs: Any) -> JSON: + """Return the JSON that would be sent to server from this model. This is an alias to `as_dict(full_restapi_key_transformer, keep_readonly=False)`. @@ -334,10 +390,17 @@ def serialize(self, keep_readonly=False, **kwargs): :rtype: dict """ serializer = Serializer(self._infer_class_models()) - return serializer._serialize(self, keep_readonly=keep_readonly, **kwargs) + return serializer._serialize( # type: ignore # pylint: disable=protected-access + self, keep_readonly=keep_readonly, **kwargs + ) - def as_dict(self, keep_readonly=True, key_transformer=attribute_transformer, **kwargs): - """Return a dict that can be JSONify using json.dump. + def as_dict( + self, + keep_readonly: bool = True, + key_transformer: Callable[[str, Dict[str, Any], Any], Any] = attribute_transformer, + **kwargs: Any + ) -> JSON: + """Return a dict that can be serialized using json.dump. Advanced usage might optionally use a callback as parameter: @@ -363,12 +426,15 @@ def my_key_transformer(key, attr_desc, value): If you want XML serialization, you can pass the kwargs is_xml=True. + :param bool keep_readonly: If you want to serialize the readonly attributes :param function key_transformer: A key transformer function. :returns: A dict JSON compatible object :rtype: dict """ serializer = Serializer(self._infer_class_models()) - return serializer._serialize(self, key_transformer=key_transformer, keep_readonly=keep_readonly, **kwargs) + return serializer._serialize( # type: ignore # pylint: disable=protected-access + self, key_transformer=key_transformer, keep_readonly=keep_readonly, **kwargs + ) @classmethod def _infer_class_models(cls): @@ -378,25 +444,31 @@ def _infer_class_models(cls): client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} if cls.__name__ not in client_models: raise ValueError("Not Autorest generated code") - except Exception: + except Exception: # pylint: disable=broad-exception-caught # Assume it's not Autorest generated (tests?). Add ourselves as dependencies. client_models = {cls.__name__: cls} return client_models @classmethod - def deserialize(cls, data, content_type=None): + def deserialize(cls: Type[ModelType], data: Any, content_type: Optional[str] = None) -> ModelType: """Parse a str using the RestAPI syntax and return a model. :param str data: A str using RestAPI structure. JSON by default. :param str content_type: JSON by default, set application/xml if XML. :returns: An instance of this model :raises: DeserializationError if something went wrong + :rtype: ModelType """ deserializer = Deserializer(cls._infer_class_models()) - return deserializer(cls.__name__, data, content_type=content_type) + return deserializer(cls.__name__, data, content_type=content_type) # type: ignore @classmethod - def from_dict(cls, data, key_extractors=None, content_type=None): + def from_dict( + cls: Type[ModelType], + data: Any, + key_extractors: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None, + content_type: Optional[str] = None, + ) -> ModelType: """Parse a dict using given key extractor return a model. By default consider key @@ -404,13 +476,15 @@ def from_dict(cls, data, key_extractors=None, content_type=None): and last_rest_key_case_insensitive_extractor) :param dict data: A dict using RestAPI structure + :param function key_extractors: A key extractor function. :param str content_type: JSON by default, set application/xml if XML. :returns: An instance of this model :raises: DeserializationError if something went wrong + :rtype: ModelType """ deserializer = Deserializer(cls._infer_class_models()) - deserializer.key_extractors = ( - [ + deserializer.key_extractors = ( # type: ignore + [ # type: ignore attribute_key_case_insensitive_extractor, rest_key_case_insensitive_extractor, last_rest_key_case_insensitive_extractor, @@ -418,7 +492,7 @@ def from_dict(cls, data, key_extractors=None, content_type=None): if key_extractors is None else key_extractors ) - return deserializer(cls.__name__, data, content_type=content_type) + return deserializer(cls.__name__, data, content_type=content_type) # type: ignore @classmethod def _flatten_subtype(cls, key, objects): @@ -426,21 +500,25 @@ def _flatten_subtype(cls, key, objects): return {} result = dict(cls._subtype_map[key]) for valuetype in cls._subtype_map[key].values(): - result.update(objects[valuetype]._flatten_subtype(key, objects)) + result.update(objects[valuetype]._flatten_subtype(key, objects)) # pylint: disable=protected-access return result @classmethod def _classify(cls, response, objects): """Check the class _subtype_map for any child classes. We want to ignore any inherited _subtype_maps. - Remove the polymorphic key from the initial data. + + :param dict response: The initial data + :param dict objects: The class objects + :returns: The class to be used + :rtype: class """ for subtype_key in cls.__dict__.get("_subtype_map", {}).keys(): subtype_value = None if not isinstance(response, ET.Element): rest_api_response_key = cls._get_rest_key_parts(subtype_key)[-1] - subtype_value = response.pop(rest_api_response_key, None) or response.pop(subtype_key, None) + subtype_value = response.get(rest_api_response_key, None) or response.get(subtype_key, None) else: subtype_value = xml_key_extractor(subtype_key, cls._attribute_map[subtype_key], response) if subtype_value: @@ -479,11 +557,13 @@ def _decode_attribute_map_key(key): inside the received data. :param str key: A key string from the generated code + :returns: The decoded key + :rtype: str """ return key.replace("\\.", ".") -class Serializer(object): +class Serializer: # pylint: disable=too-many-public-methods """Request object model serializer.""" basic_types = {str: "str", int: "int", bool: "bool", float: "float"} @@ -518,7 +598,7 @@ class Serializer(object): "multiple": lambda x, y: x % y != 0, } - def __init__(self, classes=None): + def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: self.serialize_type = { "iso-8601": Serializer.serialize_iso, "rfc-1123": Serializer.serialize_rfc, @@ -534,17 +614,20 @@ def __init__(self, classes=None): "[]": self.serialize_iter, "{}": self.serialize_dict, } - self.dependencies = dict(classes) if classes else {} + self.dependencies: Dict[str, type] = dict(classes) if classes else {} self.key_transformer = full_restapi_key_transformer self.client_side_validation = True - def _serialize(self, target_obj, data_type=None, **kwargs): + def _serialize( # pylint: disable=too-many-nested-blocks, too-many-branches, too-many-statements, too-many-locals + self, target_obj, data_type=None, **kwargs + ): """Serialize data into a string according to type. - :param target_obj: The data to be serialized. + :param object target_obj: The data to be serialized. :param str data_type: The type to be serialized from. :rtype: str, dict :raises: SerializationError if serialization fails. + :returns: The serialized data. """ key_transformer = kwargs.get("key_transformer", self.key_transformer) keep_readonly = kwargs.get("keep_readonly", False) @@ -570,12 +653,14 @@ def _serialize(self, target_obj, data_type=None, **kwargs): serialized = {} if is_xml_model_serialization: - serialized = target_obj._create_xml_node() + serialized = target_obj._create_xml_node() # pylint: disable=protected-access try: - attributes = target_obj._attribute_map + attributes = target_obj._attribute_map # pylint: disable=protected-access for attr, attr_desc in attributes.items(): attr_name = attr - if not keep_readonly and target_obj._validation.get(attr_name, {}).get("readonly", False): + if not keep_readonly and target_obj._validation.get( # pylint: disable=protected-access + attr_name, {} + ).get("readonly", False): continue if attr_name == "additional_properties" and attr_desc["key"] == "": @@ -602,7 +687,7 @@ def _serialize(self, target_obj, data_type=None, **kwargs): if xml_desc.get("attr", False): if xml_ns: ET.register_namespace(xml_prefix, xml_ns) - xml_name = "{}{}".format(xml_ns, xml_name) + xml_name = "{{{}}}{}".format(xml_ns, xml_name) serialized.set(xml_name, new_attr) # type: ignore continue if xml_desc.get("text", False): @@ -611,7 +696,8 @@ def _serialize(self, target_obj, data_type=None, **kwargs): if isinstance(new_attr, list): serialized.extend(new_attr) # type: ignore elif isinstance(new_attr, ET.Element): - # If the down XML has no XML/Name, we MUST replace the tag with the local tag. But keeping the namespaces. + # If the down XML has no XML/Name, + # we MUST replace the tag with the local tag. But keeping the namespaces. if "name" not in getattr(orig_attr, "_xml_map", {}): splitted_tag = new_attr.tag.split("}") if len(splitted_tag) == 2: # Namespace @@ -622,12 +708,11 @@ def _serialize(self, target_obj, data_type=None, **kwargs): else: # That's a basic type # Integrate namespace if necessary local_node = _create_xml_node(xml_name, xml_prefix, xml_ns) - local_node.text = unicode_str(new_attr) + local_node.text = str(new_attr) serialized.append(local_node) # type: ignore else: # JSON for k in reversed(keys): # type: ignore - unflattened = {k: new_attr} - new_attr = unflattened + new_attr = {k: new_attr} _new_attr = new_attr _serialized = serialized @@ -636,28 +721,29 @@ def _serialize(self, target_obj, data_type=None, **kwargs): _serialized.update(_new_attr) # type: ignore _new_attr = _new_attr[k] # type: ignore _serialized = _serialized[k] - except ValueError: - continue + except ValueError as err: + if isinstance(err, SerializationError): + raise except (AttributeError, KeyError, TypeError) as err: msg = "Attribute {} in object {} cannot be serialized.\n{}".format(attr_name, class_name, str(target_obj)) - raise_with_traceback(SerializationError, msg, err) - else: - return serialized + raise SerializationError(msg) from err + return serialized def body(self, data, data_type, **kwargs): """Serialize data intended for a request body. - :param data: The data to be serialized. + :param object data: The data to be serialized. :param str data_type: The type to be serialized from. :rtype: dict :raises: SerializationError if serialization fails. :raises: ValueError if data is None + :returns: The serialized request body """ # Just in case this is a dict - internal_data_type = data_type.strip("[]{}") - internal_data_type = self.dependencies.get(internal_data_type, None) + internal_data_type_str = data_type.strip("[]{}") + internal_data_type = self.dependencies.get(internal_data_type_str, None) try: is_xml_model_serialization = kwargs["is_xml"] except KeyError: @@ -681,18 +767,20 @@ def body(self, data, data_type, **kwargs): attribute_key_case_insensitive_extractor, last_rest_key_case_insensitive_extractor, ] - data = deserializer._deserialize(data_type, data) + data = deserializer._deserialize(data_type, data) # pylint: disable=protected-access except DeserializationError as err: - raise_with_traceback(SerializationError, "Unable to build a model: " + str(err), err) + raise SerializationError("Unable to build a model: " + str(err)) from err return self._serialize(data, data_type, **kwargs) def url(self, name, data, data_type, **kwargs): """Serialize data intended for a URL path. - :param data: The data to be serialized. + :param str name: The name of the URL path parameter. + :param object data: The data to be serialized. :param str data_type: The type to be serialized from. :rtype: str + :returns: The serialized URL path :raises: TypeError if serialization fails. :raises: ValueError if data is None """ @@ -703,30 +791,30 @@ def url(self, name, data, data_type, **kwargs): if kwargs.get("skip_quote") is True: output = str(output) + output = output.replace("{", quote("{")).replace("}", quote("}")) else: output = quote(str(output), safe="") - except SerializationError: - raise TypeError("{} must be type {}.".format(name, data_type)) - else: - return output + except SerializationError as exc: + raise TypeError("{} must be type {}.".format(name, data_type)) from exc + return output def query(self, name, data, data_type, **kwargs): """Serialize data intended for a URL query. - :param data: The data to be serialized. + :param str name: The name of the query parameter. + :param object data: The data to be serialized. :param str data_type: The type to be serialized from. - :rtype: str + :rtype: str, list :raises: TypeError if serialization fails. :raises: ValueError if data is None + :returns: The serialized query parameter """ try: # Treat the list aside, since we don't want to encode the div separator if data_type.startswith("["): internal_data_type = data_type[1:-1] - data = [self.serialize_data(d, internal_data_type, **kwargs) if d is not None else "" for d in data] - if not kwargs.get("skip_quote", False): - data = [quote(str(d), safe="") for d in data] - return str(self.serialize_iter(data, internal_data_type, **kwargs)) + do_quote = not kwargs.get("skip_quote", False) + return self.serialize_iter(data, internal_data_type, do_quote=do_quote, **kwargs) # Not a list, regular serialization output = self.serialize_data(data, data_type, **kwargs) @@ -736,19 +824,20 @@ def query(self, name, data, data_type, **kwargs): output = str(output) else: output = quote(str(output), safe="") - except SerializationError: - raise TypeError("{} must be type {}.".format(name, data_type)) - else: - return str(output) + except SerializationError as exc: + raise TypeError("{} must be type {}.".format(name, data_type)) from exc + return str(output) def header(self, name, data, data_type, **kwargs): """Serialize data intended for a request header. - :param data: The data to be serialized. + :param str name: The name of the header. + :param object data: The data to be serialized. :param str data_type: The type to be serialized from. :rtype: str :raises: TypeError if serialization fails. :raises: ValueError if data is None + :returns: The serialized header """ try: if data_type in ["[str]"]: @@ -757,30 +846,31 @@ def header(self, name, data, data_type, **kwargs): output = self.serialize_data(data, data_type, **kwargs) if data_type == "bool": output = json.dumps(output) - except SerializationError: - raise TypeError("{} must be type {}.".format(name, data_type)) - else: - return str(output) + except SerializationError as exc: + raise TypeError("{} must be type {}.".format(name, data_type)) from exc + return str(output) def serialize_data(self, data, data_type, **kwargs): """Serialize generic data according to supplied data type. - :param data: The data to be serialized. + :param object data: The data to be serialized. :param str data_type: The type to be serialized from. - :param bool required: Whether it's essential that the data not be - empty or None :raises: AttributeError if required data is None. :raises: ValueError if data is None :raises: SerializationError if serialization fails. + :returns: The serialized data. + :rtype: str, int, float, bool, dict, list """ if data is None: raise ValueError("No value for given attribute") try: + if data is CoreNull: + return None if data_type in self.basic_types.values(): return self.serialize_basic(data, data_type, **kwargs) - elif data_type in self.serialize_type: + if data_type in self.serialize_type: return self.serialize_type[data_type](data, **kwargs) # If dependencies is empty, try with current data class @@ -795,12 +885,11 @@ def serialize_data(self, data, data_type, **kwargs): except (ValueError, TypeError) as err: msg = "Unable to serialize value: {!r} as type: {!r}." - raise_with_traceback(SerializationError, msg.format(data, data_type), err) - else: - return self._serialize(data, **kwargs) + raise SerializationError(msg.format(data, data_type)) from err + return self._serialize(data, **kwargs) @classmethod - def _get_custom_serializers(cls, data_type, **kwargs): + def _get_custom_serializers(cls, data_type, **kwargs): # pylint: disable=inconsistent-return-statements custom_serializer = kwargs.get("basic_types_serializers", {}).get(data_type) if custom_serializer: return custom_serializer @@ -816,23 +905,26 @@ def serialize_basic(cls, data, data_type, **kwargs): - basic_types_serializers dict[str, callable] : If set, use the callable as serializer - is_xml bool : If set, use xml_basic_types_serializers - :param data: Object to be serialized. + :param obj data: Object to be serialized. :param str data_type: Type of object in the iterable. + :rtype: str, int, float, bool + :return: serialized object """ custom_serializer = cls._get_custom_serializers(data_type, **kwargs) if custom_serializer: return custom_serializer(data) if data_type == "str": return cls.serialize_unicode(data) - return eval(data_type)(data) # nosec + return eval(data_type)(data) # nosec # pylint: disable=eval-used @classmethod def serialize_unicode(cls, data): """Special handling for serializing unicode strings in Py2. Encode to UTF-8 if unicode, otherwise handle as a str. - :param data: Object to be serialized. + :param str data: Object to be serialized. :rtype: str + :return: serialized object """ try: # If I received an enum, return its value return data.value @@ -846,8 +938,7 @@ def serialize_unicode(cls, data): return data except NameError: return str(data) - else: - return str(data) + return str(data) def serialize_iter(self, data, iter_type, div=None, **kwargs): """Serialize iterable. @@ -857,13 +948,13 @@ def serialize_iter(self, data, iter_type, div=None, **kwargs): serialization_ctxt['type'] should be same as data_type. - is_xml bool : If set, serialize as XML - :param list attr: Object to be serialized. + :param list data: Object to be serialized. :param str iter_type: Type of object in the iterable. - :param bool required: Whether the objects in the iterable must - not be None or empty. :param str div: If set, this str will be used to combine the elements in the iterable into a combined string. Default is 'None'. + Defaults to False. :rtype: list, str + :return: serialized iterable """ if isinstance(data, str): raise SerializationError("Refuse str type as a valid iter type.") @@ -875,9 +966,14 @@ def serialize_iter(self, data, iter_type, div=None, **kwargs): for d in data: try: serialized.append(self.serialize_data(d, iter_type, **kwargs)) - except ValueError: + except ValueError as err: + if isinstance(err, SerializationError): + raise serialized.append(None) + if kwargs.get("do_quote", False): + serialized = ["" if s is None else quote(str(s), safe="") for s in serialized] + if div: serialized = ["" if s is None else str(s) for s in serialized] serialized = div.join(serialized) @@ -913,16 +1009,17 @@ def serialize_dict(self, attr, dict_type, **kwargs): :param dict attr: Object to be serialized. :param str dict_type: Type of object in the dictionary. - :param bool required: Whether the objects in the dictionary must - not be None or empty. :rtype: dict + :return: serialized dictionary """ serialization_ctxt = kwargs.get("serialization_ctxt", {}) serialized = {} for key, value in attr.items(): try: serialized[self.serialize_unicode(key)] = self.serialize_data(value, dict_type, **kwargs) - except ValueError: + except ValueError as err: + if isinstance(err, SerializationError): + raise serialized[self.serialize_unicode(key)] = None if "xml" in serialization_ctxt: @@ -937,7 +1034,7 @@ def serialize_dict(self, attr, dict_type, **kwargs): return serialized - def serialize_object(self, attr, **kwargs): + def serialize_object(self, attr, **kwargs): # pylint: disable=too-many-return-statements """Serialize a generic object. This will be handled as a dictionary. If object passed in is not a basic type (str, int, float, dict, list) it will simply be @@ -945,6 +1042,7 @@ def serialize_object(self, attr, **kwargs): :param dict attr: Object to be serialized. :rtype: dict or str + :return: serialized object """ if attr is None: return None @@ -955,7 +1053,7 @@ def serialize_object(self, attr, **kwargs): return self.serialize_basic(attr, self.basic_types[obj_type], **kwargs) if obj_type is _long_type: return self.serialize_long(attr) - if obj_type is unicode_str: + if obj_type is str: return self.serialize_unicode(attr) if obj_type is datetime.datetime: return self.serialize_iso(attr) @@ -969,7 +1067,7 @@ def serialize_object(self, attr, **kwargs): return self.serialize_decimal(attr) # If it's a model or I know this dependency, serialize as a Model - elif obj_type in self.dependencies.values() or isinstance(attr, Model): + if obj_type in self.dependencies.values() or isinstance(attr, Model): return self._serialize(attr) if obj_type == dict: @@ -1000,56 +1098,61 @@ def serialize_enum(attr, enum_obj=None): try: enum_obj(result) # type: ignore return result - except ValueError: + except ValueError as exc: for enum_value in enum_obj: # type: ignore if enum_value.value.lower() == str(attr).lower(): return enum_value.value error = "{!r} is not valid value for enum {!r}" - raise SerializationError(error.format(attr, enum_obj)) + raise SerializationError(error.format(attr, enum_obj)) from exc @staticmethod - def serialize_bytearray(attr, **kwargs): + def serialize_bytearray(attr, **kwargs): # pylint: disable=unused-argument """Serialize bytearray into base-64 string. - :param attr: Object to be serialized. + :param str attr: Object to be serialized. :rtype: str + :return: serialized base64 """ return b64encode(attr).decode() @staticmethod - def serialize_base64(attr, **kwargs): + def serialize_base64(attr, **kwargs): # pylint: disable=unused-argument """Serialize str into base-64 string. - :param attr: Object to be serialized. + :param str attr: Object to be serialized. :rtype: str + :return: serialized base64 """ encoded = b64encode(attr).decode("ascii") return encoded.strip("=").replace("+", "-").replace("/", "_") @staticmethod - def serialize_decimal(attr, **kwargs): + def serialize_decimal(attr, **kwargs): # pylint: disable=unused-argument """Serialize Decimal object to float. - :param attr: Object to be serialized. + :param decimal attr: Object to be serialized. :rtype: float + :return: serialized decimal """ return float(attr) @staticmethod - def serialize_long(attr, **kwargs): + def serialize_long(attr, **kwargs): # pylint: disable=unused-argument """Serialize long (Py2) or int (Py3). - :param attr: Object to be serialized. + :param int attr: Object to be serialized. :rtype: int/long + :return: serialized long """ return _long_type(attr) @staticmethod - def serialize_date(attr, **kwargs): + def serialize_date(attr, **kwargs): # pylint: disable=unused-argument """Serialize Date object into ISO-8601 formatted string. :param Date attr: Object to be serialized. :rtype: str + :return: serialized date """ if isinstance(attr, str): attr = isodate.parse_date(attr) @@ -1057,11 +1160,12 @@ def serialize_date(attr, **kwargs): return t @staticmethod - def serialize_time(attr, **kwargs): + def serialize_time(attr, **kwargs): # pylint: disable=unused-argument """Serialize Time object into ISO-8601 formatted string. :param datetime.time attr: Object to be serialized. :rtype: str + :return: serialized time """ if isinstance(attr, str): attr = isodate.parse_time(attr) @@ -1071,30 +1175,32 @@ def serialize_time(attr, **kwargs): return t @staticmethod - def serialize_duration(attr, **kwargs): + def serialize_duration(attr, **kwargs): # pylint: disable=unused-argument """Serialize TimeDelta object into ISO-8601 formatted string. :param TimeDelta attr: Object to be serialized. :rtype: str + :return: serialized duration """ if isinstance(attr, str): attr = isodate.parse_duration(attr) return isodate.duration_isoformat(attr) @staticmethod - def serialize_rfc(attr, **kwargs): + def serialize_rfc(attr, **kwargs): # pylint: disable=unused-argument """Serialize Datetime object into RFC-1123 formatted string. :param Datetime attr: Object to be serialized. :rtype: str :raises: TypeError if format invalid. + :return: serialized rfc """ try: if not attr.tzinfo: _LOGGER.warning("Datetime with no tzinfo will be considered UTC.") utc = attr.utctimetuple() - except AttributeError: - raise TypeError("RFC1123 object must be valid Datetime object.") + except AttributeError as exc: + raise TypeError("RFC1123 object must be valid Datetime object.") from exc return "{}, {:02} {} {:04} {:02}:{:02}:{:02} GMT".format( Serializer.days[utc.tm_wday], @@ -1107,12 +1213,13 @@ def serialize_rfc(attr, **kwargs): ) @staticmethod - def serialize_iso(attr, **kwargs): + def serialize_iso(attr, **kwargs): # pylint: disable=unused-argument """Serialize Datetime object into ISO-8601 formatted string. :param Datetime attr: Object to be serialized. :rtype: str :raises: SerializationError if format invalid. + :return: serialized iso """ if isinstance(attr, str): attr = isodate.parse_datetime(attr) @@ -1132,19 +1239,20 @@ def serialize_iso(attr, **kwargs): return date + microseconds + "Z" except (ValueError, OverflowError) as err: msg = "Unable to serialize datetime object." - raise_with_traceback(SerializationError, msg, err) + raise SerializationError(msg) from err except AttributeError as err: msg = "ISO-8601 object must be valid Datetime object." - raise_with_traceback(TypeError, msg, err) + raise TypeError(msg) from err @staticmethod - def serialize_unix(attr, **kwargs): + def serialize_unix(attr, **kwargs): # pylint: disable=unused-argument """Serialize Datetime object into IntTime format. This is represented as seconds. :param Datetime attr: Object to be serialized. :rtype: int :raises: SerializationError if format invalid + :return: serialied unix """ if isinstance(attr, int): return attr @@ -1152,16 +1260,17 @@ def serialize_unix(attr, **kwargs): if not attr.tzinfo: _LOGGER.warning("Datetime with no tzinfo will be considered UTC.") return int(calendar.timegm(attr.utctimetuple())) - except AttributeError: - raise TypeError("Unix time object must be valid Datetime object.") + except AttributeError as exc: + raise TypeError("Unix time object must be valid Datetime object.") from exc -def rest_key_extractor(attr, attr_desc, data): +def rest_key_extractor(attr, attr_desc, data): # pylint: disable=unused-argument key = attr_desc["key"] working_data = data while "." in key: - dict_keys = _FLATTEN.split(key) + # Need the cast, as for some reasons "split" is typed as list[str | Any] + dict_keys = cast(List[str], _FLATTEN.split(key)) if len(dict_keys) == 1: key = _decode_attribute_map_key(dict_keys[0]) break @@ -1170,14 +1279,15 @@ def rest_key_extractor(attr, attr_desc, data): if working_data is None: # If at any point while following flatten JSON path see None, it means # that all properties under are None as well - # https://github.com/Azure/msrest-for-python/issues/197 return None key = ".".join(dict_keys[1:]) return working_data.get(key) -def rest_key_case_insensitive_extractor(attr, attr_desc, data): +def rest_key_case_insensitive_extractor( # pylint: disable=unused-argument, inconsistent-return-statements + attr, attr_desc, data +): key = attr_desc["key"] working_data = data @@ -1191,7 +1301,6 @@ def rest_key_case_insensitive_extractor(attr, attr_desc, data): if working_data is None: # If at any point while following flatten JSON path see None, it means # that all properties under are None as well - # https://github.com/Azure/msrest-for-python/issues/197 return None key = ".".join(dict_keys[1:]) @@ -1199,17 +1308,29 @@ def rest_key_case_insensitive_extractor(attr, attr_desc, data): return attribute_key_case_insensitive_extractor(key, None, working_data) -def last_rest_key_extractor(attr, attr_desc, data): - """Extract the attribute in "data" based on the last part of the JSON path key.""" +def last_rest_key_extractor(attr, attr_desc, data): # pylint: disable=unused-argument + """Extract the attribute in "data" based on the last part of the JSON path key. + + :param str attr: The attribute to extract + :param dict attr_desc: The attribute description + :param dict data: The data to extract from + :rtype: object + :returns: The extracted attribute + """ key = attr_desc["key"] dict_keys = _FLATTEN.split(key) return attribute_key_extractor(dict_keys[-1], None, data) -def last_rest_key_case_insensitive_extractor(attr, attr_desc, data): +def last_rest_key_case_insensitive_extractor(attr, attr_desc, data): # pylint: disable=unused-argument """Extract the attribute in "data" based on the last part of the JSON path key. This is the case insensitive version of "last_rest_key_extractor" + :param str attr: The attribute to extract + :param dict attr_desc: The attribute description + :param dict data: The data to extract from + :rtype: object + :returns: The extracted attribute """ key = attr_desc["key"] dict_keys = _FLATTEN.split(key) @@ -1242,11 +1363,11 @@ def _extract_name_from_internal_type(internal_type): xml_name = internal_type_xml_map.get("name", internal_type.__name__) xml_ns = internal_type_xml_map.get("ns", None) if xml_ns: - xml_name = "{}{}".format(xml_ns, xml_name) + xml_name = "{{{}}}{}".format(xml_ns, xml_name) return xml_name -def xml_key_extractor(attr, attr_desc, data): +def xml_key_extractor(attr, attr_desc, data): # pylint: disable=unused-argument,too-many-return-statements if isinstance(data, dict): return None @@ -1266,7 +1387,7 @@ def xml_key_extractor(attr, attr_desc, data): # Integrate namespace if necessary xml_ns = xml_desc.get("ns", internal_type_xml_map.get("ns", None)) if xml_ns: - xml_name = "{}{}".format(xml_ns, xml_name) + xml_name = "{{{}}}{}".format(xml_ns, xml_name) # If it's an attribute, that's simple if xml_desc.get("attr", False): @@ -1298,22 +1419,21 @@ def xml_key_extractor(attr, attr_desc, data): if is_iter_type: if is_wrapped: return None # is_wrapped no node, we want None - else: - return [] # not wrapped, assume empty list + return [] # not wrapped, assume empty list return None # Assume it's not there, maybe an optional node. # If is_iter_type and not wrapped, return all found children if is_iter_type: if not is_wrapped: return children - else: # Iter and wrapped, should have found one node only (the wrap one) - if len(children) != 1: - raise DeserializationError( - "Tried to deserialize an array not wrapped, and found several nodes '{}'. Maybe you should declare this array as wrapped?".format( - xml_name - ) + # Iter and wrapped, should have found one node only (the wrap one) + if len(children) != 1: + raise DeserializationError( + "Tried to deserialize an array not wrapped, and found several nodes '{}'. Maybe you should declare this array as wrapped?".format( # pylint: disable=line-too-long + xml_name ) - return list(children[0]) # Might be empty list and that's ok. + ) + return list(children[0]) # Might be empty list and that's ok. # Here it's not a itertype, we should have found one element only or empty if len(children) > 1: @@ -1321,7 +1441,7 @@ def xml_key_extractor(attr, attr_desc, data): return children[0] -class Deserializer(object): +class Deserializer: """Response object model deserializer. :param dict classes: Class type dictionary for deserializing complex types. @@ -1330,9 +1450,9 @@ class Deserializer(object): basic_types = {str: "str", int: "int", bool: "bool", float: "float"} - valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?") + valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?") - def __init__(self, classes=None): + def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: self.deserialize_type = { "iso-8601": Deserializer.deserialize_iso, "rfc-1123": Deserializer.deserialize_rfc, @@ -1352,7 +1472,7 @@ def __init__(self, classes=None): "duration": (isodate.Duration, datetime.timedelta), "iso-8601": (datetime.datetime), } - self.dependencies = dict(classes) if classes else {} + self.dependencies: Dict[str, type] = dict(classes) if classes else {} self.key_extractors = [rest_key_extractor, xml_key_extractor] # Additional properties only works if the "rest_key_extractor" is used to # extract the keys. Making it to work whatever the key extractor is too much @@ -1370,11 +1490,12 @@ def __call__(self, target_obj, response_data, content_type=None): :param str content_type: Swagger "produces" if available. :raises: DeserializationError if deserialization fails. :return: Deserialized object. + :rtype: object """ data = self._unpack_content(response_data, content_type) return self._deserialize(target_obj, data) - def _deserialize(self, target_obj, data): + def _deserialize(self, target_obj, data): # pylint: disable=inconsistent-return-statements """Call the deserializer on a model. Data needs to be already deserialized as JSON or XML ElementTree @@ -1383,12 +1504,13 @@ def _deserialize(self, target_obj, data): :param object data: Object to deserialize. :raises: DeserializationError if deserialization fails. :return: Deserialized object. + :rtype: object """ # This is already a model, go recursive just in case if hasattr(data, "_attribute_map"): constants = [name for name, config in getattr(data, "_validation", {}).items() if config.get("constant")] try: - for attr, mapconfig in data._attribute_map.items(): + for attr, mapconfig in data._attribute_map.items(): # pylint: disable=protected-access if attr in constants: continue value = getattr(data, attr) @@ -1405,15 +1527,15 @@ def _deserialize(self, target_obj, data): response, class_name = self._classify_target(target_obj, data) - if isinstance(response, basestring): + if isinstance(response, str): return self.deserialize_data(data, response) - elif isinstance(response, type) and issubclass(response, Enum): + if isinstance(response, type) and issubclass(response, Enum): return self.deserialize_enum(data, response) - if data is None: + if data is None or data is CoreNull: return data try: - attributes = response._attribute_map # type: ignore + attributes = response._attribute_map # type: ignore # pylint: disable=protected-access d_attrs = {} for attr, attr_desc in attributes.items(): # Check empty string. If it's not empty, someone has a real "additionalProperties"... @@ -1442,10 +1564,9 @@ def _deserialize(self, target_obj, data): d_attrs[attr] = value except (AttributeError, TypeError, KeyError) as err: msg = "Unable to deserialize to object: " + class_name # type: ignore - raise_with_traceback(DeserializationError, msg, err) - else: - additional_properties = self._build_additional_properties(attributes, data) - return self._instantiate_model(response, d_attrs, additional_properties) + raise DeserializationError(msg) from err + additional_properties = self._build_additional_properties(attributes, data) + return self._instantiate_model(response, d_attrs, additional_properties) def _build_additional_properties(self, attribute_map, data): if not self.additional_properties_detection: @@ -1471,22 +1592,24 @@ def _classify_target(self, target, data): Once classification has been determined, initialize object. :param str target: The target object type to deserialize to. - :param str/dict data: The response data to deseralize. + :param str/dict data: The response data to deserialize. + :return: The classified target object and its class name. + :rtype: tuple """ if target is None: return None, None - if isinstance(target, basestring): + if isinstance(target, str): try: target = self.dependencies[target] except KeyError: return target, target try: - target = target._classify(data, self.dependencies) + target = target._classify(data, self.dependencies) # type: ignore # pylint: disable=protected-access except AttributeError: pass # Target is not a Model, no classify - return target, target.__class__.__name__ + return target, target.__class__.__name__ # type: ignore def failsafe_deserialize(self, target_obj, data, content_type=None): """Ignores any errors encountered in deserialization, @@ -1496,12 +1619,14 @@ def failsafe_deserialize(self, target_obj, data, content_type=None): a deserialization error. :param str target_obj: The target object type to deserialize to. - :param str/dict data: The response data to deseralize. + :param str/dict data: The response data to deserialize. :param str content_type: Swagger "produces" if available. + :return: Deserialized object. + :rtype: object """ try: return self(target_obj, data, content_type=content_type) - except: + except: # pylint: disable=bare-except _LOGGER.debug( "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True ) @@ -1519,10 +1644,12 @@ def _unpack_content(raw_data, content_type=None): If raw_data is something else, bypass all logic and return it directly. - :param raw_data: Data to be processed. - :param content_type: How to parse if raw_data is a string/bytes. + :param obj raw_data: Data to be processed. + :param str content_type: How to parse if raw_data is a string/bytes. :raises JSONDecodeError: If JSON is requested and parsing is impossible. :raises UnicodeDecodeError: If bytes is not UTF8 + :rtype: object + :return: Unpacked content. """ # Assume this is enough to detect a Pipeline Response without importing it context = getattr(raw_data, "context", {}) @@ -1539,31 +1666,42 @@ def _unpack_content(raw_data, content_type=None): if hasattr(raw_data, "_content_consumed"): return RawDeserializer.deserialize_from_http_generics(raw_data.text, raw_data.headers) - if isinstance(raw_data, (basestring, bytes)) or hasattr(raw_data, "read"): + if isinstance(raw_data, (str, bytes)) or hasattr(raw_data, "read"): return RawDeserializer.deserialize_from_text(raw_data, content_type) # type: ignore return raw_data def _instantiate_model(self, response, attrs, additional_properties=None): """Instantiate a response model passing in deserialized args. - :param response: The response model class. - :param d_attrs: The deserialized response attributes. + :param Response response: The response model class. + :param dict attrs: The deserialized response attributes. + :param dict additional_properties: Additional properties to be set. + :rtype: Response + :return: The instantiated response model. """ if callable(response): subtype = getattr(response, "_subtype_map", {}) try: - readonly = [k for k, v in response._validation.items() if v.get("readonly")] - const = [k for k, v in response._validation.items() if v.get("constant")] + readonly = [ + k + for k, v in response._validation.items() # pylint: disable=protected-access # type: ignore + if v.get("readonly") + ] + const = [ + k + for k, v in response._validation.items() # pylint: disable=protected-access # type: ignore + 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 + response_obj.additional_properties = additional_properties # type: ignore return response_obj except TypeError as err: msg = "Unable to deserialize {} into model {}. ".format(kwargs, response) # type: ignore - raise DeserializationError(msg + str(err)) + raise DeserializationError(msg + str(err)) from err else: try: for attr, value in attrs.items(): @@ -1572,15 +1710,16 @@ def _instantiate_model(self, response, attrs, additional_properties=None): except Exception as exp: msg = "Unable to populate response model. " msg += "Type: {}, Error: {}".format(type(response), exp) - raise DeserializationError(msg) + raise DeserializationError(msg) from exp - def deserialize_data(self, data, data_type): + def deserialize_data(self, data, data_type): # pylint: disable=too-many-return-statements """Process data for deserialization according to data type. :param str data: The response string to be deserialized. :param str data_type: The type to deserialize to. :raises: DeserializationError if deserialization fails. :return: Deserialized object. + :rtype: object """ if data is None: return data @@ -1594,7 +1733,11 @@ def deserialize_data(self, data, data_type): if isinstance(data, self.deserialize_expected_types.get(data_type, tuple())): return data - is_a_text_parsing_type = lambda x: x not in ["object", "[]", r"{}"] + is_a_text_parsing_type = lambda x: x not in [ # pylint: disable=unnecessary-lambda-assignment + "object", + "[]", + r"{}", + ] if isinstance(data, ET.Element) and is_a_text_parsing_type(data_type) and not data.text: return None data_val = self.deserialize_type[data_type](data) @@ -1613,15 +1756,15 @@ def deserialize_data(self, data, data_type): except (ValueError, TypeError, AttributeError) as err: msg = "Unable to deserialize response data." msg += " Data: {}, {}".format(data, data_type) - raise_with_traceback(DeserializationError, msg, err) - else: - return self._deserialize(obj_type, data) + raise DeserializationError(msg) from err + return self._deserialize(obj_type, data) def deserialize_iter(self, attr, iter_type): """Deserialize an iterable. :param list attr: Iterable to be deserialized. :param str iter_type: The type of object in the iterable. + :return: Deserialized iterable. :rtype: list """ if attr is None: @@ -1638,6 +1781,7 @@ def deserialize_dict(self, attr, dict_type): :param dict/list attr: Dictionary to be deserialized. Also accepts a list of key, value pairs. :param str dict_type: The object type of the items in the dictionary. + :return: Deserialized dictionary. :rtype: dict """ if isinstance(attr, list): @@ -1648,11 +1792,12 @@ def deserialize_dict(self, attr, dict_type): attr = {el.tag: el.text for el in attr} return {k: self.deserialize_data(v, dict_type) for k, v in attr.items()} - def deserialize_object(self, attr, **kwargs): + def deserialize_object(self, attr, **kwargs): # pylint: disable=too-many-return-statements """Deserialize a generic object. This will be handled as a dictionary. :param dict attr: Dictionary to be deserialized. + :return: Deserialized object. :rtype: dict :raises: TypeError if non-builtin datatype encountered. """ @@ -1661,7 +1806,7 @@ def deserialize_object(self, attr, **kwargs): if isinstance(attr, ET.Element): # Do no recurse on XML, just return the tree as-is return attr - if isinstance(attr, basestring): + if isinstance(attr, str): return self.deserialize_basic(attr, "str") obj_type = type(attr) if obj_type in self.basic_types: @@ -1687,11 +1832,10 @@ def deserialize_object(self, attr, **kwargs): pass return deserialized - else: - error = "Cannot deserialize generic object with type: " - raise TypeError(error + str(obj_type)) + error = "Cannot deserialize generic object with type: " + raise TypeError(error + str(obj_type)) - def deserialize_basic(self, attr, data_type): + def deserialize_basic(self, attr, data_type): # pylint: disable=too-many-return-statements """Deserialize basic builtin data type from string. Will attempt to convert to str, int, float and bool. This function will also accept '1', '0', 'true' and 'false' as @@ -1699,6 +1843,7 @@ def deserialize_basic(self, attr, data_type): :param str attr: response string to be deserialized. :param str data_type: deserialization data type. + :return: Deserialized basic type. :rtype: str, int, float or bool :raises: TypeError if string format is not valid. """ @@ -1710,24 +1855,23 @@ def deserialize_basic(self, attr, data_type): if data_type == "str": # None or '', node is empty string. return "" - else: - # None or '', node with a strong type is None. - # Don't try to model "empty bool" or "empty int" - return None + # None or '', node with a strong type is None. + # Don't try to model "empty bool" or "empty int" + return None if data_type == "bool": if attr in [True, False, 1, 0]: return bool(attr) - elif isinstance(attr, basestring): + if isinstance(attr, str): if attr.lower() in ["true", "1"]: return True - elif attr.lower() in ["false", "0"]: + if attr.lower() in ["false", "0"]: return False raise TypeError("Invalid boolean value: {}".format(attr)) if data_type == "str": return self.deserialize_unicode(attr) - return eval(data_type)(attr) # nosec + return eval(data_type)(attr) # nosec # pylint: disable=eval-used @staticmethod def deserialize_unicode(data): @@ -1735,6 +1879,7 @@ def deserialize_unicode(data): as a string. :param str data: response string to be deserialized. + :return: Deserialized string. :rtype: str or unicode """ # We might be here because we have an enum modeled as string, @@ -1748,8 +1893,7 @@ def deserialize_unicode(data): return data except NameError: return str(data) - else: - return str(data) + return str(data) @staticmethod def deserialize_enum(data, enum_obj): @@ -1761,6 +1905,7 @@ def deserialize_enum(data, enum_obj): :param str data: Response string to be deserialized. If this value is None or invalid it will be returned as-is. :param Enum enum_obj: Enum object to deserialize to. + :return: Deserialized enum object. :rtype: Enum """ if isinstance(data, enum_obj) or data is None: @@ -1769,12 +1914,11 @@ def deserialize_enum(data, enum_obj): data = data.value if isinstance(data, int): # Workaround. We might consider remove it in the future. - # https://github.com/Azure/azure-rest-api-specs/issues/141 try: return list(enum_obj.__members__.values())[data] - except IndexError: + except IndexError as exc: error = "{!r} is not a valid index for enum {!r}" - raise DeserializationError(error.format(data, enum_obj)) + raise DeserializationError(error.format(data, enum_obj)) from exc try: return enum_obj(str(data)) except ValueError: @@ -1790,6 +1934,7 @@ def deserialize_bytearray(attr): """Deserialize string into bytearray. :param str attr: response string to be deserialized. + :return: Deserialized bytearray :rtype: bytearray :raises: TypeError if string format invalid. """ @@ -1802,6 +1947,7 @@ def deserialize_base64(attr): """Deserialize base64 encoded string into string. :param str attr: response string to be deserialized. + :return: Deserialized base64 string :rtype: bytearray :raises: TypeError if string format invalid. """ @@ -1817,22 +1963,24 @@ def deserialize_decimal(attr): """Deserialize string into Decimal object. :param str attr: response string to be deserialized. - :rtype: Decimal + :return: Deserialized decimal :raises: DeserializationError if string format invalid. + :rtype: decimal """ if isinstance(attr, ET.Element): attr = attr.text try: - return decimal.Decimal(attr) # type: ignore + return decimal.Decimal(str(attr)) # type: ignore except decimal.DecimalException as err: msg = "Invalid decimal {}".format(attr) - raise_with_traceback(DeserializationError, msg, err) + raise DeserializationError(msg) from err @staticmethod def deserialize_long(attr): """Deserialize string into long (Py2) or int (Py3). :param str attr: response string to be deserialized. + :return: Deserialized int :rtype: long or int :raises: ValueError if string format invalid. """ @@ -1845,6 +1993,7 @@ def deserialize_duration(attr): """Deserialize ISO-8601 formatted string into TimeDelta object. :param str attr: response string to be deserialized. + :return: Deserialized duration :rtype: TimeDelta :raises: DeserializationError if string format invalid. """ @@ -1854,15 +2003,15 @@ def deserialize_duration(attr): duration = isodate.parse_duration(attr) except (ValueError, OverflowError, AttributeError) as err: msg = "Cannot deserialize duration object." - raise_with_traceback(DeserializationError, msg, err) - else: - return duration + raise DeserializationError(msg) from err + return duration @staticmethod def deserialize_date(attr): """Deserialize ISO-8601 formatted string into Date object. :param str attr: response string to be deserialized. + :return: Deserialized date :rtype: Date :raises: DeserializationError if string format invalid. """ @@ -1871,13 +2020,14 @@ def deserialize_date(attr): if re.search(r"[^\W\d_]", attr, re.I + re.U): # type: ignore raise DeserializationError("Date must have only digits and -. Received: %s" % attr) # This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception. - return isodate.parse_date(attr, defaultmonth=None, defaultday=None) + return isodate.parse_date(attr, defaultmonth=0, defaultday=0) @staticmethod def deserialize_time(attr): """Deserialize ISO-8601 formatted string into time object. :param str attr: response string to be deserialized. + :return: Deserialized time :rtype: datetime.time :raises: DeserializationError if string format invalid. """ @@ -1892,6 +2042,7 @@ def deserialize_rfc(attr): """Deserialize RFC-1123 formatted string into Datetime object. :param str attr: response string to be deserialized. + :return: Deserialized RFC datetime :rtype: Datetime :raises: DeserializationError if string format invalid. """ @@ -1906,15 +2057,15 @@ def deserialize_rfc(attr): date_obj = date_obj.astimezone(tz=TZ_UTC) except ValueError as err: msg = "Cannot deserialize to rfc datetime object." - raise_with_traceback(DeserializationError, msg, err) - else: - return date_obj + raise DeserializationError(msg) from err + return date_obj @staticmethod def deserialize_iso(attr): """Deserialize ISO-8601 formatted string into Datetime object. :param str attr: response string to be deserialized. + :return: Deserialized ISO datetime :rtype: Datetime :raises: DeserializationError if string format invalid. """ @@ -1943,9 +2094,8 @@ def deserialize_iso(attr): raise OverflowError("Hit max or min date") except (ValueError, OverflowError, AttributeError) as err: msg = "Cannot deserialize datetime object." - raise_with_traceback(DeserializationError, msg, err) - else: - return date_obj + raise DeserializationError(msg) from err + return date_obj @staticmethod def deserialize_unix(attr): @@ -1953,15 +2103,16 @@ def deserialize_unix(attr): This is represented as seconds. :param int attr: Object to be serialized. + :return: Deserialized datetime :rtype: Datetime :raises: DeserializationError if format invalid """ if isinstance(attr, ET.Element): attr = int(attr.text) # type: ignore try: + attr = int(attr) date_obj = datetime.datetime.fromtimestamp(attr, TZ_UTC) except ValueError as err: msg = "Cannot deserialize to unix datetime object." - raise_with_traceback(DeserializationError, msg, err) - else: - return date_obj + raise DeserializationError(msg) from err + return date_obj diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_subscription_client.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_subscription_client.py index 469be1f14747..4aeaa913aaf6 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_subscription_client.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_subscription_client.py @@ -8,9 +8,12 @@ from copy import deepcopy from typing import Any, TYPE_CHECKING +from typing_extensions import Self +from azure.core.pipeline import policies from azure.core.rest import HttpRequest, HttpResponse from azure.mgmt.core import ARMPipelineClient +from azure.mgmt.core.policies import ARMAutoResourceProviderRegistrationPolicy from . import models as _models from ._configuration import SubscriptionClientConfiguration @@ -19,6 +22,7 @@ AliasOperations, BillingAccountOperations, Operations, + SubscriptionOperationOperations, SubscriptionOperations, SubscriptionPolicyOperations, SubscriptionsOperations, @@ -26,7 +30,6 @@ ) if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials import TokenCredential @@ -39,6 +42,9 @@ class SubscriptionClient: # pylint: disable=client-accepts-api-version-keyword, :vartype tenants: azure.mgmt.subscription.operations.TenantsOperations :ivar subscription: SubscriptionOperations operations :vartype subscription: azure.mgmt.subscription.operations.SubscriptionOperations + :ivar subscription_operation: SubscriptionOperationOperations operations + :vartype subscription_operation: + azure.mgmt.subscription.operations.SubscriptionOperationOperations :ivar operations: Operations operations :vartype operations: azure.mgmt.subscription.operations.Operations :ivar alias: AliasOperations operations @@ -59,7 +65,25 @@ def __init__( self, credential: "TokenCredential", base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: self._config = SubscriptionClientConfiguration(credential=credential, **kwargs) - self._client = ARMPipelineClient(base_url=base_url, config=self._config, **kwargs) + _policies = kwargs.pop("policies", None) + if _policies is None: + _policies = [ + policies.RequestIdPolicy(**kwargs), + self._config.headers_policy, + self._config.user_agent_policy, + self._config.proxy_policy, + policies.ContentDecodePolicy(**kwargs), + ARMAutoResourceProviderRegistrationPolicy(), + self._config.redirect_policy, + self._config.retry_policy, + self._config.authentication_policy, + self._config.custom_hook_policy, + self._config.logging_policy, + policies.DistributedTracingPolicy(**kwargs), + policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, + self._config.http_logging_policy, + ] + self._client: ARMPipelineClient = ARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) @@ -68,6 +92,9 @@ def __init__( self.subscriptions = SubscriptionsOperations(self._client, self._config, self._serialize, self._deserialize) self.tenants = TenantsOperations(self._client, self._config, self._serialize, self._deserialize) self.subscription = SubscriptionOperations(self._client, self._config, self._serialize, self._deserialize) + self.subscription_operation = SubscriptionOperationOperations( + self._client, self._config, self._serialize, self._deserialize + ) self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) self.alias = AliasOperations(self._client, self._config, self._serialize, self._deserialize) self.subscription_policy = SubscriptionPolicyOperations( @@ -75,7 +102,7 @@ def __init__( ) self.billing_account = BillingAccountOperations(self._client, self._config, self._serialize, self._deserialize) - def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: + def _send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -95,14 +122,14 @@ def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: request_copy = deepcopy(request) request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, **kwargs) + return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore def close(self) -> None: self._client.close() - def __enter__(self) -> "SubscriptionClient": + def __enter__(self) -> Self: self._client.__enter__() return self - def __exit__(self, *exc_details) -> None: + def __exit__(self, *exc_details: Any) -> None: self._client.__exit__(*exc_details) diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_vendor.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_vendor.py deleted file mode 100644 index 9aad73fc743e..000000000000 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_vendor.py +++ /dev/null @@ -1,27 +0,0 @@ -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from azure.core.pipeline.transport import HttpRequest - - -def _convert_request(request, files=None): - data = request.content if not files else None - request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) - if files: - request.set_formdata_body(files) - return request - - -def _format_url_section(template, **kwargs): - components = template.split("/") - while components: - try: - return template.format(**kwargs) - except KeyError as key: - formatted_components = template.split("/") - components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] - template = "/".join(components) diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_version.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_version.py index e46fe87dc038..509b38085125 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_version.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "3.2.0b1" +VERSION = "3.2.0" diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/__init__.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/__init__.py index cee23feb3f8b..bb5ad1b4e042 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/__init__.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/__init__.py @@ -5,12 +5,18 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._subscription_client import SubscriptionClient +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._subscription_client import SubscriptionClient # type: ignore try: from ._patch import __all__ as _patch_all - from ._patch import * # pylint: disable=unused-wildcard-import + from ._patch import * except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk @@ -18,6 +24,6 @@ __all__ = [ "SubscriptionClient", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/_configuration.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/_configuration.py index c3e5601d1d62..24c7785cf99d 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/_configuration.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/_configuration.py @@ -8,18 +8,16 @@ from typing import Any, TYPE_CHECKING -from azure.core.configuration import Configuration from azure.core.pipeline import policies from azure.mgmt.core.policies import ARMHttpLoggingPolicy, AsyncARMChallengeAuthenticationPolicy from .._version import VERSION if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials_async import AsyncTokenCredential -class SubscriptionClientConfiguration(Configuration): # pylint: disable=too-many-instance-attributes +class SubscriptionClientConfiguration: # pylint: disable=too-many-instance-attributes """Configuration for SubscriptionClient. Note that all parameters used to create this instance are saved as instance @@ -30,13 +28,13 @@ class SubscriptionClientConfiguration(Configuration): # pylint: disable=too-man """ def __init__(self, credential: "AsyncTokenCredential", **kwargs: Any) -> None: - super(SubscriptionClientConfiguration, self).__init__(**kwargs) if credential is None: raise ValueError("Parameter 'credential' must not be None.") self.credential = credential self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) kwargs.setdefault("sdk_moniker", "mgmt-subscription/{}".format(VERSION)) + self.polling_interval = kwargs.get("polling_interval", 30) self._configure(**kwargs) def _configure(self, **kwargs: Any) -> None: @@ -45,9 +43,9 @@ def _configure(self, **kwargs: Any) -> None: self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs) self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs) self.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**kwargs) - self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) + self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) self.authentication_policy = kwargs.get("authentication_policy") if self.credential and not self.authentication_policy: self.authentication_policy = AsyncARMChallengeAuthenticationPolicy( diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/_patch.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/_patch.py index f99e77fef986..17dbc073e01b 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/_patch.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/_patch.py @@ -25,6 +25,7 @@ # # -------------------------------------------------------------------------- + # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/_subscription_client.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/_subscription_client.py index 94baea0fdc2d..2e3fcd091885 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/_subscription_client.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/_subscription_client.py @@ -8,9 +8,12 @@ from copy import deepcopy from typing import Any, Awaitable, TYPE_CHECKING +from typing_extensions import Self +from azure.core.pipeline import policies from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.mgmt.core import AsyncARMPipelineClient +from azure.mgmt.core.policies import AsyncARMAutoResourceProviderRegistrationPolicy from .. import models as _models from .._serialization import Deserializer, Serializer @@ -19,6 +22,7 @@ AliasOperations, BillingAccountOperations, Operations, + SubscriptionOperationOperations, SubscriptionOperations, SubscriptionPolicyOperations, SubscriptionsOperations, @@ -26,7 +30,6 @@ ) if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials_async import AsyncTokenCredential @@ -39,6 +42,9 @@ class SubscriptionClient: # pylint: disable=client-accepts-api-version-keyword, :vartype tenants: azure.mgmt.subscription.aio.operations.TenantsOperations :ivar subscription: SubscriptionOperations operations :vartype subscription: azure.mgmt.subscription.aio.operations.SubscriptionOperations + :ivar subscription_operation: SubscriptionOperationOperations operations + :vartype subscription_operation: + azure.mgmt.subscription.aio.operations.SubscriptionOperationOperations :ivar operations: Operations operations :vartype operations: azure.mgmt.subscription.aio.operations.Operations :ivar alias: AliasOperations operations @@ -60,7 +66,25 @@ def __init__( self, credential: "AsyncTokenCredential", base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: self._config = SubscriptionClientConfiguration(credential=credential, **kwargs) - self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **kwargs) + _policies = kwargs.pop("policies", None) + if _policies is None: + _policies = [ + policies.RequestIdPolicy(**kwargs), + self._config.headers_policy, + self._config.user_agent_policy, + self._config.proxy_policy, + policies.ContentDecodePolicy(**kwargs), + AsyncARMAutoResourceProviderRegistrationPolicy(), + self._config.redirect_policy, + self._config.retry_policy, + self._config.authentication_policy, + self._config.custom_hook_policy, + self._config.logging_policy, + policies.DistributedTracingPolicy(**kwargs), + policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, + self._config.http_logging_policy, + ] + self._client: AsyncARMPipelineClient = AsyncARMPipelineClient(base_url=base_url, policies=_policies, **kwargs) client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) @@ -69,6 +93,9 @@ def __init__( self.subscriptions = SubscriptionsOperations(self._client, self._config, self._serialize, self._deserialize) self.tenants = TenantsOperations(self._client, self._config, self._serialize, self._deserialize) self.subscription = SubscriptionOperations(self._client, self._config, self._serialize, self._deserialize) + self.subscription_operation = SubscriptionOperationOperations( + self._client, self._config, self._serialize, self._deserialize + ) self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) self.alias = AliasOperations(self._client, self._config, self._serialize, self._deserialize) self.subscription_policy = SubscriptionPolicyOperations( @@ -76,7 +103,9 @@ def __init__( ) self.billing_account = BillingAccountOperations(self._client, self._config, self._serialize, self._deserialize) - def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: + def _send_request( + self, request: HttpRequest, *, stream: bool = False, **kwargs: Any + ) -> Awaitable[AsyncHttpResponse]: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -96,14 +125,14 @@ def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncH request_copy = deepcopy(request) request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, **kwargs) + return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore async def close(self) -> None: await self._client.close() - async def __aenter__(self) -> "SubscriptionClient": + async def __aenter__(self) -> Self: await self._client.__aenter__() return self - async def __aexit__(self, *exc_details) -> None: + async def __aexit__(self, *exc_details: Any) -> None: await self._client.__aexit__(*exc_details) diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/__init__.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/__init__.py index 532abd5a6165..bfa9e7d69460 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/__init__.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/__init__.py @@ -5,27 +5,35 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._subscriptions_operations import SubscriptionsOperations -from ._tenants_operations import TenantsOperations -from ._subscription_operations import SubscriptionOperations -from ._operations import Operations -from ._alias_operations import AliasOperations -from ._subscription_policy_operations import SubscriptionPolicyOperations -from ._billing_account_operations import BillingAccountOperations +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._subscriptions_operations import SubscriptionsOperations # type: ignore +from ._tenants_operations import TenantsOperations # type: ignore +from ._subscription_operations import SubscriptionOperations # type: ignore +from ._subscription_operation_operations import SubscriptionOperationOperations # type: ignore +from ._operations import Operations # type: ignore +from ._alias_operations import AliasOperations # type: ignore +from ._subscription_policy_operations import SubscriptionPolicyOperations # type: ignore +from ._billing_account_operations import BillingAccountOperations # type: ignore from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import +from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ "SubscriptionsOperations", "TenantsOperations", "SubscriptionOperations", + "SubscriptionOperationOperations", "Operations", "AliasOperations", "SubscriptionPolicyOperations", "BillingAccountOperations", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_alias_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_alias_operations.py index 465d1a545db9..aa1e005104f8 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_alias_operations.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_alias_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,8 +5,9 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +from typing import Any, AsyncIterator, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload from azure.core.exceptions import ( ClientAuthenticationError, @@ -15,19 +15,19 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import HttpRequest +from azure.core.rest import AsyncHttpResponse, 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 azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling from ... import models as _models -from ..._vendor import _convert_request from ...operations._alias_operations import ( build_create_request, build_delete_request, @@ -35,10 +35,10 @@ build_list_request, ) -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -63,9 +63,9 @@ def __init__(self, *args, **kwargs) -> None: self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") async def _create_initial( - self, alias_name: str, body: Union[_models.PutAliasRequest, IO], **kwargs: Any - ) -> _models.SubscriptionAliasResponse: - error_map = { + self, alias_name: str, body: Union[_models.PutAliasRequest, IO[bytes]], **kwargs: Any + ) -> AsyncIterator[bytes]: + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -76,55 +76,53 @@ async def _create_initial( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.SubscriptionAliasResponse] = kwargs.pop("cls", None) + cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(body, (IO, bytes)): + if isinstance(body, (IOBase, bytes)): _content = body else: _json = self._serialize.body(body, "PutAliasRequest") - request = build_create_request( + _request = build_create_request( alias_name=alias_name, api_version=api_version, content_type=content_type, json=_json, content=_content, - template_url=self._create_initial.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) + _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response if response.status_code not in [200, 201]: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("SubscriptionAliasResponse", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("SubscriptionAliasResponse", pipeline_response) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore return deserialized # type: ignore - _create_initial.metadata = {"url": "/providers/Microsoft.Subscription/aliases/{aliasName}"} - @overload async def begin_create( self, alias_name: str, body: _models.PutAliasRequest, *, content_type: str = "application/json", **kwargs: Any @@ -140,14 +138,6 @@ async def begin_create( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :keyword str continuation_token: A continuation token to restart a poller from a saved state. - :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for - this operation to not poll, or pass in your own initialized polling object for a personal - polling strategy. - :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. :return: An instance of AsyncLROPoller that returns either SubscriptionAliasResponse or the result of cls(response) :rtype: @@ -157,7 +147,7 @@ async def begin_create( @overload async def begin_create( - self, alias_name: str, body: IO, *, content_type: str = "application/json", **kwargs: Any + self, alias_name: str, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any ) -> AsyncLROPoller[_models.SubscriptionAliasResponse]: """Create Alias Subscription. @@ -166,18 +156,10 @@ async def begin_create( request for subscription creation. Required. :type alias_name: str :param body: Required. - :type body: IO + :type body: IO[bytes] :keyword content_type: Body Parameter content-type. Content type parameter for binary body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :keyword str continuation_token: A continuation token to restart a poller from a saved state. - :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for - this operation to not poll, or pass in your own initialized polling object for a personal - polling strategy. - :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. :return: An instance of AsyncLROPoller that returns either SubscriptionAliasResponse or the result of cls(response) :rtype: @@ -187,7 +169,7 @@ async def begin_create( @distributed_trace_async async def begin_create( - self, alias_name: str, body: Union[_models.PutAliasRequest, IO], **kwargs: Any + self, alias_name: str, body: Union[_models.PutAliasRequest, IO[bytes]], **kwargs: Any ) -> AsyncLROPoller[_models.SubscriptionAliasResponse]: """Create Alias Subscription. @@ -195,19 +177,8 @@ async def begin_create( is not the same as subscription name and this doesn’t have any other lifecycle need beyond the request for subscription creation. Required. :type alias_name: str - :param body: Is either a model type or a IO type. Required. - :type body: ~azure.mgmt.subscription.models.PutAliasRequest or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :keyword str continuation_token: A continuation token to restart a poller from a saved state. - :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for - this operation to not poll, or pass in your own initialized polling object for a personal - polling strategy. - :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. + :param body: Is either a PutAliasRequest type or a IO[bytes] type. Required. + :type body: ~azure.mgmt.subscription.models.PutAliasRequest or IO[bytes] :return: An instance of AsyncLROPoller that returns either SubscriptionAliasResponse or the result of cls(response) :rtype: @@ -217,7 +188,7 @@ async def begin_create( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.SubscriptionAliasResponse] = kwargs.pop("cls", None) polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) @@ -234,12 +205,13 @@ async def begin_create( params=_params, **kwargs ) + await raw_result.http_response.read() # type: ignore kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize("SubscriptionAliasResponse", pipeline_response) + deserialized = self._deserialize("SubscriptionAliasResponse", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore return deserialized if polling is True: @@ -249,15 +221,15 @@ def get_long_running_output(pipeline_response): else: polling_method = polling if cont_token: - return AsyncLROPoller.from_continuation_token( + return AsyncLROPoller[_models.SubscriptionAliasResponse].from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, deserialization_callback=get_long_running_output, ) - return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - begin_create.metadata = {"url": "/providers/Microsoft.Subscription/aliases/{aliasName}"} + return AsyncLROPoller[_models.SubscriptionAliasResponse]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) @distributed_trace_async async def get(self, alias_name: str, **kwargs: Any) -> _models.SubscriptionAliasResponse: @@ -267,12 +239,11 @@ async def get(self, alias_name: str, **kwargs: Any) -> _models.SubscriptionAlias is not the same as subscription name and this doesn’t have any other lifecycle need beyond the request for subscription creation. Required. :type alias_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: SubscriptionAliasResponse or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.SubscriptionAliasResponse :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -283,21 +254,20 @@ async def get(self, alias_name: str, **kwargs: Any) -> _models.SubscriptionAlias _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.SubscriptionAliasResponse] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( alias_name=alias_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) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -307,29 +277,26 @@ async def get(self, alias_name: str, **kwargs: Any) -> _models.SubscriptionAlias error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("SubscriptionAliasResponse", pipeline_response) + deserialized = self._deserialize("SubscriptionAliasResponse", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - get.metadata = {"url": "/providers/Microsoft.Subscription/aliases/{aliasName}"} + return deserialized # type: ignore @distributed_trace_async - async def delete(self, alias_name: str, **kwargs: Any) -> None: # pylint: disable=inconsistent-return-statements + async def delete(self, alias_name: str, **kwargs: Any) -> None: """Delete Alias. :param alias_name: AliasName is the name for the subscription creation request. Note that this is not the same as subscription name and this doesn’t have any other lifecycle need beyond the request for subscription creation. Required. :type alias_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: None or the result of cls(response) :rtype: None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -340,21 +307,20 @@ async def delete(self, alias_name: str, **kwargs: Any) -> None: # pylint: disab _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[None] = kwargs.pop("cls", None) - request = build_delete_request( + _request = build_delete_request( alias_name=alias_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) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -365,20 +331,17 @@ async def delete(self, alias_name: str, **kwargs: Any) -> None: # pylint: disab raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: - return cls(pipeline_response, None, {}) - - delete.metadata = {"url": "/providers/Microsoft.Subscription/aliases/{aliasName}"} + return cls(pipeline_response, None, {}) # type: ignore @distributed_trace_async async def list(self, **kwargs: Any) -> _models.SubscriptionAliasListResult: """List Alias Subscription. - :keyword callable cls: A custom type or function that will be passed the direct response :return: SubscriptionAliasListResult or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.SubscriptionAliasListResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -389,20 +352,19 @@ async def list(self, **kwargs: Any) -> _models.SubscriptionAliasListResult: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.SubscriptionAliasListResult] = kwargs.pop("cls", None) - request = build_list_request( + _request = build_list_request( api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -412,11 +374,9 @@ async def list(self, **kwargs: Any) -> _models.SubscriptionAliasListResult: error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("SubscriptionAliasListResult", pipeline_response) + deserialized = self._deserialize("SubscriptionAliasListResult", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - list.metadata = {"url": "/providers/Microsoft.Subscription/aliases"} + return deserialized # type: ignore diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_billing_account_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_billing_account_operations.py index 6aaf16c9eeb2..a53a8a390710 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_billing_account_operations.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_billing_account_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -18,20 +17,18 @@ map_error, ) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse -from azure.core.rest import HttpRequest +from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.core.tracing.decorator_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._billing_account_operations import build_get_policy_request -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -61,12 +58,11 @@ async def get_policy(self, billing_account_id: str, **kwargs: Any) -> _models.Bi :param billing_account_id: Billing Account Id. Required. :type billing_account_id: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: BillingAccountPoliciesResponse or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.BillingAccountPoliciesResponse :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -77,21 +73,20 @@ async def get_policy(self, billing_account_id: str, **kwargs: Any) -> _models.Bi _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.BillingAccountPoliciesResponse] = kwargs.pop("cls", None) - request = build_get_policy_request( + _request = build_get_policy_request( billing_account_id=billing_account_id, api_version=api_version, - template_url=self.get_policy.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -101,13 +96,9 @@ async def get_policy(self, billing_account_id: str, **kwargs: Any) -> _models.Bi error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("BillingAccountPoliciesResponse", pipeline_response) + deserialized = self._deserialize("BillingAccountPoliciesResponse", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get_policy.metadata = { - "url": "/providers/Microsoft.Billing/billingAccounts/{billingAccountId}/providers/Microsoft.Subscription/policies/default" - } + return deserialized # type: ignore diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_operations.py index 2c830b8f332e..f0da44af2fbf 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_operations.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -19,20 +18,18 @@ map_error, ) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse -from azure.core.rest import HttpRequest +from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.core.tracing.decorator import distributed_trace from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat from ... import models as _models -from ..._vendor import _convert_request from ...operations._operations import build_list_request -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -60,7 +57,6 @@ def __init__(self, *args, **kwargs) -> None: def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: """Lists all of the available Microsoft.Subscription API operations. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either Operation or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.subscription.models.Operation] :raises ~azure.core.exceptions.HttpResponseError: @@ -68,10 +64,10 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -82,21 +78,18 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: - request = HttpRequest("GET", next_link) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request = HttpRequest("GET", next_link) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request async def extract_data(pipeline_response): deserialized = self._deserialize("OperationListResult", pipeline_response) @@ -106,10 +99,11 @@ async def extract_data(pipeline_response): return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -121,5 +115,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list.metadata = {"url": "/providers/Microsoft.Subscription/operations"} diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscription_operation_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscription_operation_operations.py new file mode 100644 index 000000000000..a898cdd77aa1 --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscription_operation_operations.py @@ -0,0 +1,112 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import sys +from typing import Any, Callable, Dict, Optional, TypeVar + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) +from azure.core.pipeline import PipelineResponse +from azure.core.rest import AsyncHttpResponse, HttpRequest +from azure.core.tracing.decorator_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 ...operations._subscription_operation_operations import build_get_request + +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping +else: + from typing import MutableMapping # type: ignore +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + + +class SubscriptionOperationOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.subscription.aio.SubscriptionClient`'s + :attr:`subscription_operation` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client = input_args.pop(0) if input_args else kwargs.pop("client") + self._config = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace_async + async def get(self, operation_id: str, **kwargs: Any) -> Optional[_models.SubscriptionCreationResult]: + """Get the status of the pending Microsoft.Subscription API operations. + + :param operation_id: The operation ID, which can be found from the Location field in the + generate recommendation response header. Required. + :type operation_id: str + :return: SubscriptionCreationResult or None or the result of cls(response) + :rtype: ~azure.mgmt.subscription.models.SubscriptionCreationResult or None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + cls: ClsType[Optional[_models.SubscriptionCreationResult]] = kwargs.pop("cls", None) + + _request = build_get_request( + operation_id=operation_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = None + response_headers = {} + if response.status_code == 200: + deserialized = self._deserialize("SubscriptionCreationResult", pipeline_response.http_response) + + if response.status_code == 202: + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscription_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscription_operations.py index b286154abb73..0d76f35e5dfb 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscription_operations.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscription_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,8 +5,9 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +from typing import Any, AsyncIterator, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload from azure.core.exceptions import ( ClientAuthenticationError, @@ -15,19 +15,19 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod -from azure.core.rest import HttpRequest +from azure.core.rest import AsyncHttpResponse, 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 azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling from ... import models as _models -from ..._vendor import _convert_request from ...operations._subscription_operations import ( build_accept_ownership_request, build_accept_ownership_status_request, @@ -36,10 +36,10 @@ build_rename_request, ) -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -69,12 +69,11 @@ async def cancel(self, subscription_id: str, **kwargs: Any) -> _models.CanceledS :param subscription_id: Subscription Id. Required. :type subscription_id: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: CanceledSubscriptionId or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.CanceledSubscriptionId :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -85,21 +84,20 @@ async def cancel(self, subscription_id: str, **kwargs: Any) -> _models.CanceledS _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.CanceledSubscriptionId] = kwargs.pop("cls", None) - request = build_cancel_request( + _request = build_cancel_request( subscription_id=subscription_id, api_version=api_version, - template_url=self.cancel.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -109,14 +107,12 @@ async def cancel(self, subscription_id: str, **kwargs: Any) -> _models.CanceledS error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("CanceledSubscriptionId", pipeline_response) + deserialized = self._deserialize("CanceledSubscriptionId", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - cancel.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Subscription/cancel"} + return deserialized # type: ignore @overload async def rename( @@ -136,7 +132,6 @@ async def rename( :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: RenamedSubscriptionId or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.RenamedSubscriptionId :raises ~azure.core.exceptions.HttpResponseError: @@ -144,18 +139,17 @@ async def rename( @overload async def rename( - self, subscription_id: str, body: IO, *, content_type: str = "application/json", **kwargs: Any + self, subscription_id: str, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any ) -> _models.RenamedSubscriptionId: """The operation to rename a subscription. :param subscription_id: Subscription Id. Required. :type subscription_id: str :param body: Subscription Name. Required. - :type body: IO + :type body: IO[bytes] :keyword content_type: Body Parameter content-type. Content type parameter for binary body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: RenamedSubscriptionId or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.RenamedSubscriptionId :raises ~azure.core.exceptions.HttpResponseError: @@ -163,23 +157,20 @@ async def rename( @distributed_trace_async async def rename( - self, subscription_id: str, body: Union[_models.SubscriptionName, IO], **kwargs: Any + self, subscription_id: str, body: Union[_models.SubscriptionName, IO[bytes]], **kwargs: Any ) -> _models.RenamedSubscriptionId: """The operation to rename a subscription. :param subscription_id: Subscription Id. Required. :type subscription_id: str - :param body: Subscription Name. Is either a model type or a IO type. Required. - :type body: ~azure.mgmt.subscription.models.SubscriptionName or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response + :param body: Subscription Name. Is either a SubscriptionName type or a IO[bytes] type. + Required. + :type body: ~azure.mgmt.subscription.models.SubscriptionName or IO[bytes] :return: RenamedSubscriptionId or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.RenamedSubscriptionId :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -190,33 +181,32 @@ async def rename( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.RenamedSubscriptionId] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(body, (IO, bytes)): + if isinstance(body, (IOBase, bytes)): _content = body else: _json = self._serialize.body(body, "SubscriptionName") - request = build_rename_request( + _request = build_rename_request( subscription_id=subscription_id, api_version=api_version, content_type=content_type, json=_json, content=_content, - template_url=self.rename.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -226,14 +216,12 @@ async def rename( error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("RenamedSubscriptionId", pipeline_response) + deserialized = self._deserialize("RenamedSubscriptionId", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - rename.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Subscription/rename"} + return deserialized # type: ignore @distributed_trace_async async def enable(self, subscription_id: str, **kwargs: Any) -> _models.EnabledSubscriptionId: @@ -241,12 +229,11 @@ async def enable(self, subscription_id: str, **kwargs: Any) -> _models.EnabledSu :param subscription_id: Subscription Id. Required. :type subscription_id: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: EnabledSubscriptionId or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.EnabledSubscriptionId :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -257,21 +244,20 @@ async def enable(self, subscription_id: str, **kwargs: Any) -> _models.EnabledSu _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.EnabledSubscriptionId] = kwargs.pop("cls", None) - request = build_enable_request( + _request = build_enable_request( subscription_id=subscription_id, api_version=api_version, - template_url=self.enable.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -281,19 +267,17 @@ async def enable(self, subscription_id: str, **kwargs: Any) -> _models.EnabledSu error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("EnabledSubscriptionId", pipeline_response) + deserialized = self._deserialize("EnabledSubscriptionId", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized + return deserialized # type: ignore - enable.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Subscription/enable"} - - async def _accept_ownership_initial( # pylint: disable=inconsistent-return-statements - self, subscription_id: str, body: Union[_models.AcceptOwnershipRequest, IO], **kwargs: Any - ) -> None: - error_map = { + async def _accept_ownership_initial( + self, subscription_id: str, body: Union[_models.AcceptOwnershipRequest, IO[bytes]], **kwargs: Any + ) -> AsyncIterator[bytes]: + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -304,38 +288,42 @@ async def _accept_ownership_initial( # pylint: disable=inconsistent-return-stat _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[None] = kwargs.pop("cls", None) + cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(body, (IO, bytes)): + if isinstance(body, (IOBase, bytes)): _content = body else: _json = self._serialize.body(body, "AcceptOwnershipRequest") - request = build_accept_ownership_request( + _request = build_accept_ownership_request( subscription_id=subscription_id, api_version=api_version, content_type=content_type, json=_json, content=_content, - template_url=self._accept_ownership_initial.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) + _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response if response.status_code not in [202]: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) @@ -344,12 +332,12 @@ async def _accept_ownership_initial( # pylint: disable=inconsistent-return-stat response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + if cls: - return cls(pipeline_response, None, response_headers) + return cls(pipeline_response, deserialized, response_headers) # type: ignore - _accept_ownership_initial.metadata = { - "url": "/providers/Microsoft.Subscription/subscriptions/{subscriptionId}/acceptOwnership" - } + return deserialized # type: ignore @overload async def begin_accept_ownership( @@ -369,14 +357,6 @@ async def begin_accept_ownership( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :keyword str continuation_token: A continuation token to restart a poller from a saved state. - :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for - this operation to not poll, or pass in your own initialized polling object for a personal - polling strategy. - :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[None] :raises ~azure.core.exceptions.HttpResponseError: @@ -384,25 +364,17 @@ async def begin_accept_ownership( @overload async def begin_accept_ownership( - self, subscription_id: str, body: IO, *, content_type: str = "application/json", **kwargs: Any + self, subscription_id: str, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any ) -> AsyncLROPoller[None]: """Accept subscription ownership. :param subscription_id: Subscription Id. Required. :type subscription_id: str :param body: Required. - :type body: IO + :type body: IO[bytes] :keyword content_type: Body Parameter content-type. Content type parameter for binary body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :keyword str continuation_token: A continuation token to restart a poller from a saved state. - :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for - this operation to not poll, or pass in your own initialized polling object for a personal - polling strategy. - :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[None] :raises ~azure.core.exceptions.HttpResponseError: @@ -410,25 +382,14 @@ async def begin_accept_ownership( @distributed_trace_async async def begin_accept_ownership( - self, subscription_id: str, body: Union[_models.AcceptOwnershipRequest, IO], **kwargs: Any + self, subscription_id: str, body: Union[_models.AcceptOwnershipRequest, IO[bytes]], **kwargs: Any ) -> AsyncLROPoller[None]: """Accept subscription ownership. :param subscription_id: Subscription Id. Required. :type subscription_id: str - :param body: Is either a model type or a IO type. Required. - :type body: ~azure.mgmt.subscription.models.AcceptOwnershipRequest or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :keyword str continuation_token: A continuation token to restart a poller from a saved state. - :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for - this operation to not poll, or pass in your own initialized polling object for a personal - polling strategy. - :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. + :param body: Is either a AcceptOwnershipRequest type or a IO[bytes] type. Required. + :type body: ~azure.mgmt.subscription.models.AcceptOwnershipRequest or IO[bytes] :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[None] :raises ~azure.core.exceptions.HttpResponseError: @@ -436,14 +397,14 @@ async def begin_accept_ownership( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[None] = kwargs.pop("cls", None) polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: - raw_result = await self._accept_ownership_initial( # type: ignore + raw_result = await self._accept_ownership_initial( subscription_id=subscription_id, body=body, api_version=api_version, @@ -453,11 +414,12 @@ async def begin_accept_ownership( params=_params, **kwargs ) + await raw_result.http_response.read() # type: ignore kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: - return cls(pipeline_response, None, {}) + return cls(pipeline_response, None, {}) # type: ignore if polling is True: polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) @@ -466,17 +428,13 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- else: polling_method = polling if cont_token: - return AsyncLROPoller.from_continuation_token( + return AsyncLROPoller[None].from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, deserialization_callback=get_long_running_output, ) - return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - begin_accept_ownership.metadata = { - "url": "/providers/Microsoft.Subscription/subscriptions/{subscriptionId}/acceptOwnership" - } + return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore @distributed_trace_async async def accept_ownership_status( @@ -486,12 +444,11 @@ async def accept_ownership_status( :param subscription_id: Subscription Id. Required. :type subscription_id: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: AcceptOwnershipStatusResponse or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.AcceptOwnershipStatusResponse :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -502,21 +459,20 @@ async def accept_ownership_status( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.AcceptOwnershipStatusResponse] = kwargs.pop("cls", None) - request = build_accept_ownership_status_request( + _request = build_accept_ownership_status_request( subscription_id=subscription_id, api_version=api_version, - template_url=self.accept_ownership_status.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -526,13 +482,9 @@ async def accept_ownership_status( error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("AcceptOwnershipStatusResponse", pipeline_response) + deserialized = self._deserialize("AcceptOwnershipStatusResponse", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - accept_ownership_status.metadata = { - "url": "/providers/Microsoft.Subscription/subscriptions/{subscriptionId}/acceptOwnershipStatus" - } + return deserialized # type: ignore diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscription_policy_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscription_policy_operations.py index 40456472d270..42c7e0fca2d6 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscription_policy_operations.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscription_policy_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,6 +5,7 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +from io import IOBase import sys from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload @@ -19,25 +19,23 @@ map_error, ) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse -from azure.core.rest import HttpRequest +from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.core.tracing.decorator import distributed_trace from azure.core.tracing.decorator_async import distributed_trace_async from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat from ... import models as _models -from ..._vendor import _convert_request from ...operations._subscription_policy_operations import ( build_add_update_policy_for_tenant_request, build_get_policy_for_tenant_request, build_list_policy_for_tenant_request, ) -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -72,7 +70,6 @@ async def add_update_policy_for_tenant( :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: GetTenantPolicyResponse or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.GetTenantPolicyResponse :raises ~azure.core.exceptions.HttpResponseError: @@ -80,16 +77,15 @@ async def add_update_policy_for_tenant( @overload async def add_update_policy_for_tenant( - self, body: IO, *, content_type: str = "application/json", **kwargs: Any + self, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any ) -> _models.GetTenantPolicyResponse: """Create or Update Subscription tenant policy for user's tenant. :param body: Required. - :type body: IO + :type body: IO[bytes] :keyword content_type: Body Parameter content-type. Content type parameter for binary body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: GetTenantPolicyResponse or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.GetTenantPolicyResponse :raises ~azure.core.exceptions.HttpResponseError: @@ -97,21 +93,17 @@ async def add_update_policy_for_tenant( @distributed_trace_async async def add_update_policy_for_tenant( - self, body: Union[_models.PutTenantPolicyRequestProperties, IO], **kwargs: Any + self, body: Union[_models.PutTenantPolicyRequestProperties, IO[bytes]], **kwargs: Any ) -> _models.GetTenantPolicyResponse: """Create or Update Subscription tenant policy for user's tenant. - :param body: Is either a model type or a IO type. Required. - :type body: ~azure.mgmt.subscription.models.PutTenantPolicyRequestProperties or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response + :param body: Is either a PutTenantPolicyRequestProperties type or a IO[bytes] type. Required. + :type body: ~azure.mgmt.subscription.models.PutTenantPolicyRequestProperties or IO[bytes] :return: GetTenantPolicyResponse or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.GetTenantPolicyResponse :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -122,32 +114,31 @@ async def add_update_policy_for_tenant( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.GetTenantPolicyResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(body, (IO, bytes)): + if isinstance(body, (IOBase, bytes)): _content = body else: _json = self._serialize.body(body, "PutTenantPolicyRequestProperties") - request = build_add_update_policy_for_tenant_request( + _request = build_add_update_policy_for_tenant_request( api_version=api_version, content_type=content_type, json=_json, content=_content, - template_url=self.add_update_policy_for_tenant.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -157,25 +148,22 @@ async def add_update_policy_for_tenant( error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("GetTenantPolicyResponse", pipeline_response) + deserialized = self._deserialize("GetTenantPolicyResponse", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - add_update_policy_for_tenant.metadata = {"url": "/providers/Microsoft.Subscription/policies/default"} + return deserialized # type: ignore @distributed_trace_async async def get_policy_for_tenant(self, **kwargs: Any) -> _models.GetTenantPolicyResponse: """Get the subscription tenant policy for the user's tenant. - :keyword callable cls: A custom type or function that will be passed the direct response :return: GetTenantPolicyResponse or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.GetTenantPolicyResponse :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -186,20 +174,19 @@ async def get_policy_for_tenant(self, **kwargs: Any) -> _models.GetTenantPolicyR _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.GetTenantPolicyResponse] = kwargs.pop("cls", None) - request = build_get_policy_for_tenant_request( + _request = build_get_policy_for_tenant_request( api_version=api_version, - template_url=self.get_policy_for_tenant.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -209,20 +196,17 @@ async def get_policy_for_tenant(self, **kwargs: Any) -> _models.GetTenantPolicyR error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("GetTenantPolicyResponse", pipeline_response) + deserialized = self._deserialize("GetTenantPolicyResponse", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get_policy_for_tenant.metadata = {"url": "/providers/Microsoft.Subscription/policies/default"} + return deserialized # type: ignore @distributed_trace def list_policy_for_tenant(self, **kwargs: Any) -> AsyncIterable["_models.GetTenantPolicyResponse"]: """Get the subscription tenant policy for the user's tenant. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either GetTenantPolicyResponse or the result of cls(response) :rtype: @@ -232,10 +216,10 @@ def list_policy_for_tenant(self, **kwargs: Any) -> AsyncIterable["_models.GetTen _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.GetTenantPolicyListResponse] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -246,21 +230,18 @@ def list_policy_for_tenant(self, **kwargs: Any) -> AsyncIterable["_models.GetTen def prepare_request(next_link=None): if not next_link: - request = build_list_policy_for_tenant_request( + _request = build_list_policy_for_tenant_request( api_version=api_version, - template_url=self.list_policy_for_tenant.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: - request = HttpRequest("GET", next_link) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request = HttpRequest("GET", next_link) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request async def extract_data(pipeline_response): deserialized = self._deserialize("GetTenantPolicyListResponse", pipeline_response) @@ -270,10 +251,11 @@ async def extract_data(pipeline_response): return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -285,5 +267,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list_policy_for_tenant.metadata = {"url": "/providers/Microsoft.Subscription/policies"} diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscriptions_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscriptions_operations.py index 4ccb0b19749a..d734150e66eb 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscriptions_operations.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_subscriptions_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -19,21 +18,19 @@ map_error, ) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse -from azure.core.rest import HttpRequest +from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.core.tracing.decorator import distributed_trace from azure.core.tracing.decorator_async import distributed_trace_async from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat from ... import models as _models -from ..._vendor import _convert_request from ...operations._subscriptions_operations import build_get_request, build_list_locations_request, build_list_request -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -66,7 +63,6 @@ def list_locations(self, subscription_id: str, **kwargs: Any) -> AsyncIterable[" :param subscription_id: The ID of the target subscription. Required. :type subscription_id: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either Location or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.subscription.models.Location] :raises ~azure.core.exceptions.HttpResponseError: @@ -74,10 +70,10 @@ def list_locations(self, subscription_id: str, **kwargs: Any) -> AsyncIterable[" _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2016-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) cls: ClsType[_models.LocationListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -88,22 +84,19 @@ def list_locations(self, subscription_id: str, **kwargs: Any) -> AsyncIterable[" def prepare_request(next_link=None): if not next_link: - request = build_list_locations_request( + _request = build_list_locations_request( subscription_id=subscription_id, api_version=api_version, - template_url=self.list_locations.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: - request = HttpRequest("GET", next_link) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request = HttpRequest("GET", next_link) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request async def extract_data(pipeline_response): deserialized = self._deserialize("LocationListResult", pipeline_response) @@ -113,10 +106,11 @@ async def extract_data(pipeline_response): return None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -128,20 +122,17 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_locations.metadata = {"url": "/subscriptions/{subscriptionId}/locations"} - @distributed_trace_async async def get(self, subscription_id: str, **kwargs: Any) -> _models.Subscription: """Gets details about a specified subscription. :param subscription_id: The ID of the target subscription. Required. :type subscription_id: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: Subscription or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.Subscription :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -152,21 +143,20 @@ async def get(self, subscription_id: str, **kwargs: Any) -> _models.Subscription _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2016-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) cls: ClsType[_models.Subscription] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( subscription_id=subscription_id, api_version=api_version, - template_url=self.get.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -175,20 +165,17 @@ async def get(self, subscription_id: str, **kwargs: Any) -> _models.Subscription map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - deserialized = self._deserialize("Subscription", pipeline_response) + deserialized = self._deserialize("Subscription", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - get.metadata = {"url": "/subscriptions/{subscriptionId}"} + return deserialized # type: ignore @distributed_trace def list(self, **kwargs: Any) -> AsyncIterable["_models.Subscription"]: """Gets all subscriptions for a tenant. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either Subscription or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.subscription.models.Subscription] :raises ~azure.core.exceptions.HttpResponseError: @@ -196,10 +183,10 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.Subscription"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2016-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) cls: ClsType[_models.SubscriptionListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -210,21 +197,18 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.Subscription"]: def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: - request = HttpRequest("GET", next_link) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request = HttpRequest("GET", next_link) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request async def extract_data(pipeline_response): deserialized = self._deserialize("SubscriptionListResult", pipeline_response) @@ -234,10 +218,11 @@ async def extract_data(pipeline_response): return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -248,5 +233,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions"} diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_tenants_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_tenants_operations.py index 0c71ef538b84..a8a66cbd85cf 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_tenants_operations.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/aio/operations/_tenants_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -19,20 +18,18 @@ map_error, ) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse -from azure.core.rest import HttpRequest +from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.core.tracing.decorator import distributed_trace from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat from ... import models as _models -from ..._vendor import _convert_request from ...operations._tenants_operations import build_list_request -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -60,7 +57,6 @@ def __init__(self, *args, **kwargs) -> None: def list(self, **kwargs: Any) -> AsyncIterable["_models.TenantIdDescription"]: """Gets the tenants for your account. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either TenantIdDescription or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.subscription.models.TenantIdDescription] @@ -69,10 +65,10 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.TenantIdDescription"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2016-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) cls: ClsType[_models.TenantListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -83,21 +79,18 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.TenantIdDescription"]: def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: - request = HttpRequest("GET", next_link) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request = HttpRequest("GET", next_link) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request async def extract_data(pipeline_response): deserialized = self._deserialize("TenantListResult", pipeline_response) @@ -107,10 +100,11 @@ async def extract_data(pipeline_response): return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) + _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -121,5 +115,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list.metadata = {"url": "/tenants"} diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/models/__init__.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/models/__init__.py index aacbb44efeb7..03392da05e4a 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/models/__init__.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/models/__init__.py @@ -5,50 +5,62 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._models_py3 import AcceptOwnershipRequest -from ._models_py3 import AcceptOwnershipRequestProperties -from ._models_py3 import AcceptOwnershipStatusResponse -from ._models_py3 import BillingAccountPoliciesResponse -from ._models_py3 import BillingAccountPoliciesResponseProperties -from ._models_py3 import CanceledSubscriptionId -from ._models_py3 import EnabledSubscriptionId -from ._models_py3 import ErrorResponse -from ._models_py3 import ErrorResponseBody -from ._models_py3 import GetTenantPolicyListResponse -from ._models_py3 import GetTenantPolicyResponse -from ._models_py3 import Location -from ._models_py3 import LocationListResult -from ._models_py3 import Operation -from ._models_py3 import OperationDisplay -from ._models_py3 import OperationListResult -from ._models_py3 import PutAliasRequest -from ._models_py3 import PutAliasRequestAdditionalProperties -from ._models_py3 import PutAliasRequestProperties -from ._models_py3 import PutTenantPolicyRequestProperties -from ._models_py3 import RenamedSubscriptionId -from ._models_py3 import ServiceTenantResponse -from ._models_py3 import Subscription -from ._models_py3 import SubscriptionAliasListResult -from ._models_py3 import SubscriptionAliasResponse -from ._models_py3 import SubscriptionAliasResponseProperties -from ._models_py3 import SubscriptionListResult -from ._models_py3 import SubscriptionName -from ._models_py3 import SubscriptionPolicies -from ._models_py3 import SystemData -from ._models_py3 import TenantIdDescription -from ._models_py3 import TenantListResult -from ._models_py3 import TenantPolicy +from typing import TYPE_CHECKING -from ._subscription_client_enums import AcceptOwnership -from ._subscription_client_enums import CreatedByType -from ._subscription_client_enums import Provisioning -from ._subscription_client_enums import ProvisioningState -from ._subscription_client_enums import SpendingLimit -from ._subscription_client_enums import SubscriptionState -from ._subscription_client_enums import Workload +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + + +from ._models_py3 import ( # type: ignore + AcceptOwnershipRequest, + AcceptOwnershipRequestProperties, + AcceptOwnershipStatusResponse, + BillingAccountPoliciesResponse, + BillingAccountPoliciesResponseProperties, + CanceledSubscriptionId, + EnabledSubscriptionId, + ErrorResponse, + ErrorResponseBody, + GetTenantPolicyListResponse, + GetTenantPolicyResponse, + Location, + LocationListResult, + Operation, + OperationDisplay, + OperationListResult, + PutAliasRequest, + PutAliasRequestAdditionalProperties, + PutAliasRequestProperties, + PutTenantPolicyRequestProperties, + RenamedSubscriptionId, + ServiceTenantResponse, + Subscription, + SubscriptionAliasListResult, + SubscriptionAliasResponse, + SubscriptionAliasResponseProperties, + SubscriptionCreationResult, + SubscriptionListResult, + SubscriptionName, + SubscriptionPolicies, + SystemData, + TenantIdDescription, + TenantListResult, + TenantPolicy, +) + +from ._subscription_client_enums import ( # type: ignore + AcceptOwnership, + CreatedByType, + Provisioning, + ProvisioningState, + SpendingLimit, + SubscriptionState, + Workload, +) from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import +from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ @@ -78,6 +90,7 @@ "SubscriptionAliasListResult", "SubscriptionAliasResponse", "SubscriptionAliasResponseProperties", + "SubscriptionCreationResult", "SubscriptionListResult", "SubscriptionName", "SubscriptionPolicies", @@ -93,5 +106,5 @@ "SubscriptionState", "Workload", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/models/_models_py3.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/models/_models_py3.py index b5851f7b2986..a63af2719d5b 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/models/_models_py3.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/models/_models_py3.py @@ -1,5 +1,5 @@ -# coding=utf-8 # pylint: disable=too-many-lines +# coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. @@ -8,12 +8,11 @@ # -------------------------------------------------------------------------- import datetime -from typing import Dict, List, Optional, TYPE_CHECKING, Union +from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union from .. import _serialization if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from .. import models as _models @@ -28,7 +27,9 @@ class AcceptOwnershipRequest(_serialization.Model): "properties": {"key": "properties", "type": "AcceptOwnershipRequestProperties"}, } - def __init__(self, *, properties: Optional["_models.AcceptOwnershipRequestProperties"] = None, **kwargs): + def __init__( + self, *, properties: Optional["_models.AcceptOwnershipRequestProperties"] = None, **kwargs: Any + ) -> None: """ :keyword properties: Accept subscription ownership request properties. :paramtype properties: ~azure.mgmt.subscription.models.AcceptOwnershipRequestProperties @@ -40,7 +41,7 @@ def __init__(self, *, properties: Optional["_models.AcceptOwnershipRequestProper class AcceptOwnershipRequestProperties(_serialization.Model): """Accept subscription ownership request properties. - All required parameters must be populated in order to send to Azure. + All required parameters must be populated in order to send to server. :ivar display_name: The friendly name of the subscription. Required. :vartype display_name: str @@ -66,8 +67,8 @@ def __init__( display_name: str, management_group_id: Optional[str] = None, tags: Optional[Dict[str, str]] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword display_name: The friendly name of the subscription. Required. :paramtype display_name: str @@ -128,8 +129,8 @@ def __init__( subscription_tenant_id: Optional[str] = None, display_name: Optional[str] = None, tags: Optional[Dict[str, str]] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword subscription_tenant_id: Tenant Id of the subscription. :paramtype subscription_tenant_id: str @@ -180,7 +181,9 @@ class BillingAccountPoliciesResponse(_serialization.Model): "system_data": {"key": "systemData", "type": "SystemData"}, } - def __init__(self, *, properties: Optional["_models.BillingAccountPoliciesResponseProperties"] = None, **kwargs): + def __init__( + self, *, properties: Optional["_models.BillingAccountPoliciesResponseProperties"] = None, **kwargs: Any + ) -> None: """ :keyword properties: Billing account policies response properties. :paramtype properties: ~azure.mgmt.subscription.models.BillingAccountPoliciesResponseProperties @@ -212,8 +215,8 @@ def __init__( *, service_tenants: Optional[List["_models.ServiceTenantResponse"]] = None, allow_transfers: Optional[bool] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword service_tenants: Service tenant for the billing account. :paramtype service_tenants: list[~azure.mgmt.subscription.models.ServiceTenantResponse] @@ -242,7 +245,7 @@ class CanceledSubscriptionId(_serialization.Model): "subscription_id": {"key": "subscriptionId", "type": "str"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) self.subscription_id = None @@ -265,7 +268,7 @@ class EnabledSubscriptionId(_serialization.Model): "subscription_id": {"key": "subscriptionId", "type": "str"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) self.subscription_id = None @@ -285,7 +288,7 @@ class ErrorResponse(_serialization.Model): "message": {"key": "message", "type": "str"}, } - def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs): + def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs: Any) -> None: """ :keyword code: Error code. :paramtype code: str @@ -298,7 +301,8 @@ def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, class ErrorResponseBody(_serialization.Model): - """Error response indicates that the service is not able to process the incoming request. The reason is provided in the error message. + """Error response indicates that the service is not able to process the incoming request. The + reason is provided in the error message. :ivar error: The details of the error. :vartype error: ~azure.mgmt.subscription.models.ErrorResponse @@ -320,8 +324,8 @@ def __init__( error: Optional["_models.ErrorResponse"] = None, code: Optional[str] = None, message: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword error: The details of the error. :paramtype error: ~azure.mgmt.subscription.models.ErrorResponse @@ -357,7 +361,7 @@ class GetTenantPolicyListResponse(_serialization.Model): "next_link": {"key": "nextLink", "type": "str"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) self.value = None @@ -396,7 +400,7 @@ class GetTenantPolicyResponse(_serialization.Model): "system_data": {"key": "systemData", "type": "SystemData"}, } - def __init__(self, *, properties: Optional["_models.TenantPolicy"] = None, **kwargs): + def __init__(self, *, properties: Optional["_models.TenantPolicy"] = None, **kwargs: Any) -> None: """ :keyword properties: Tenant policy properties. :paramtype properties: ~azure.mgmt.subscription.models.TenantPolicy @@ -447,7 +451,7 @@ class Location(_serialization.Model): "longitude": {"key": "longitude", "type": "str"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) self.id = None @@ -469,7 +473,7 @@ class LocationListResult(_serialization.Model): "value": {"key": "value", "type": "[Location]"}, } - def __init__(self, *, value: Optional[List["_models.Location"]] = None, **kwargs): + def __init__(self, *, value: Optional[List["_models.Location"]] = None, **kwargs: Any) -> None: """ :keyword value: An array of locations. :paramtype value: list[~azure.mgmt.subscription.models.Location] @@ -501,8 +505,8 @@ def __init__( name: Optional[str] = None, is_data_action: Optional[bool] = None, display: Optional["_models.OperationDisplay"] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword name: Operation name: {provider}/{resource}/{operation}. :paramtype name: str @@ -544,8 +548,8 @@ def __init__( resource: Optional[str] = None, operation: Optional[str] = None, description: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword provider: Service provider: Microsoft.Subscription. :paramtype provider: str @@ -564,7 +568,8 @@ def __init__( class OperationListResult(_serialization.Model): - """Result of the request to list operations. It contains a list of operations and a URL link to get the next set of results. + """Result of the request to list operations. It contains a list of operations and a URL link to + get the next set of results. :ivar value: List of operations. :vartype value: list[~azure.mgmt.subscription.models.Operation] @@ -577,7 +582,9 @@ class OperationListResult(_serialization.Model): "next_link": {"key": "nextLink", "type": "str"}, } - def __init__(self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs): + def __init__( + self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs: Any + ) -> None: """ :keyword value: List of operations. :paramtype value: list[~azure.mgmt.subscription.models.Operation] @@ -600,7 +607,7 @@ class PutAliasRequest(_serialization.Model): "properties": {"key": "properties", "type": "PutAliasRequestProperties"}, } - def __init__(self, *, properties: Optional["_models.PutAliasRequestProperties"] = None, **kwargs): + def __init__(self, *, properties: Optional["_models.PutAliasRequestProperties"] = None, **kwargs: Any) -> None: """ :keyword properties: Put alias request properties. :paramtype properties: ~azure.mgmt.subscription.models.PutAliasRequestProperties @@ -636,8 +643,8 @@ def __init__( subscription_tenant_id: Optional[str] = None, subscription_owner_id: Optional[str] = None, tags: Optional[Dict[str, str]] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword management_group_id: Management group Id for the subscription. :paramtype management_group_id: str @@ -697,8 +704,8 @@ def __init__( subscription_id: Optional[str] = None, reseller_id: Optional[str] = None, additional_properties: Optional["_models.PutAliasRequestAdditionalProperties"] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword display_name: The friendly name of the subscription. :paramtype display_name: str @@ -755,8 +762,8 @@ def __init__( block_subscriptions_leaving_tenant: Optional[bool] = None, block_subscriptions_into_tenant: Optional[bool] = None, exempted_principals: Optional[List[str]] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword block_subscriptions_leaving_tenant: Blocks the leaving of subscriptions from user's tenant. @@ -791,7 +798,7 @@ class RenamedSubscriptionId(_serialization.Model): "subscription_id": {"key": "subscriptionId", "type": "str"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) self.subscription_id = None @@ -811,7 +818,7 @@ class ServiceTenantResponse(_serialization.Model): "tenant_name": {"key": "tenantName", "type": "str"}, } - def __init__(self, *, tenant_id: Optional[str] = None, tenant_name: Optional[str] = None, **kwargs): + def __init__(self, *, tenant_id: Optional[str] = None, tenant_name: Optional[str] = None, **kwargs: Any) -> None: """ :keyword tenant_id: Service tenant id. :paramtype tenant_id: str @@ -875,8 +882,8 @@ def __init__( tags: Optional[Dict[str, str]] = None, subscription_policies: Optional["_models.SubscriptionPolicies"] = None, authorization_source: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword tags: Tags for the subscription. :paramtype tags: dict[str, str] @@ -919,7 +926,7 @@ class SubscriptionAliasListResult(_serialization.Model): "next_link": {"key": "nextLink", "type": "str"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) self.value = None @@ -958,7 +965,9 @@ class SubscriptionAliasResponse(_serialization.Model): "system_data": {"key": "systemData", "type": "SystemData"}, } - def __init__(self, *, properties: Optional["_models.SubscriptionAliasResponseProperties"] = None, **kwargs): + def __init__( + self, *, properties: Optional["_models.SubscriptionAliasResponseProperties"] = None, **kwargs: Any + ) -> None: """ :keyword properties: Subscription Alias response properties. :paramtype properties: ~azure.mgmt.subscription.models.SubscriptionAliasResponseProperties @@ -971,7 +980,7 @@ def __init__(self, *, properties: Optional["_models.SubscriptionAliasResponsePro self.system_data = None -class SubscriptionAliasResponseProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes +class SubscriptionAliasResponseProperties(_serialization.Model): """Put subscription creation result properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -1043,8 +1052,8 @@ def __init__( management_group_id: Optional[str] = None, created_time: Optional[str] = None, tags: Optional[Dict[str, str]] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword display_name: The display name of the subscription. :paramtype display_name: str @@ -1087,6 +1096,28 @@ def __init__( self.tags = tags +class SubscriptionCreationResult(_serialization.Model): + """The created subscription object. + + :ivar subscription_link: The link to the new subscription. Use this link to check the status of + subscription creation operation. + :vartype subscription_link: str + """ + + _attribute_map = { + "subscription_link": {"key": "subscriptionLink", "type": "str"}, + } + + def __init__(self, *, subscription_link: Optional[str] = None, **kwargs: Any) -> None: + """ + :keyword subscription_link: The link to the new subscription. Use this link to check the status + of subscription creation operation. + :paramtype subscription_link: str + """ + super().__init__(**kwargs) + self.subscription_link = subscription_link + + class SubscriptionListResult(_serialization.Model): """Subscription list operation response. @@ -1102,8 +1133,8 @@ class SubscriptionListResult(_serialization.Model): } def __init__( - self, *, value: Optional[List["_models.Subscription"]] = None, next_link: Optional[str] = None, **kwargs - ): + self, *, value: Optional[List["_models.Subscription"]] = None, next_link: Optional[str] = None, **kwargs: Any + ) -> None: """ :keyword value: An array of subscriptions. :paramtype value: list[~azure.mgmt.subscription.models.Subscription] @@ -1126,7 +1157,7 @@ class SubscriptionName(_serialization.Model): "subscription_name": {"key": "subscriptionName", "type": "str"}, } - def __init__(self, *, subscription_name: Optional[str] = None, **kwargs): + def __init__(self, *, subscription_name: Optional[str] = None, **kwargs: Any) -> None: """ :keyword subscription_name: New subscription name. :paramtype subscription_name: str @@ -1163,7 +1194,7 @@ class SubscriptionPolicies(_serialization.Model): "spending_limit": {"key": "spendingLimit", "type": "str"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) self.location_placement_id = None @@ -1208,8 +1239,8 @@ def __init__( last_modified_by: Optional[str] = None, last_modified_by_type: Optional[Union[str, "_models.CreatedByType"]] = None, last_modified_at: Optional[datetime.datetime] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword created_by: The identity that created the resource. :paramtype created_by: str @@ -1286,7 +1317,7 @@ class TenantIdDescription(_serialization.Model): "tenant_type": {"key": "tenantType", "type": "str"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) self.id = None @@ -1303,7 +1334,7 @@ def __init__(self, **kwargs): class TenantListResult(_serialization.Model): """Tenant Ids information. - All required parameters must be populated in order to send to Azure. + All required parameters must be populated in order to send to server. :ivar value: An array of tenants. :vartype value: list[~azure.mgmt.subscription.models.TenantIdDescription] @@ -1320,7 +1351,9 @@ class TenantListResult(_serialization.Model): "next_link": {"key": "nextLink", "type": "str"}, } - def __init__(self, *, next_link: str, value: Optional[List["_models.TenantIdDescription"]] = None, **kwargs): + def __init__( + self, *, next_link: str, value: Optional[List["_models.TenantIdDescription"]] = None, **kwargs: Any + ) -> None: """ :keyword value: An array of tenants. :paramtype value: list[~azure.mgmt.subscription.models.TenantIdDescription] @@ -1366,8 +1399,8 @@ def __init__( block_subscriptions_leaving_tenant: Optional[bool] = None, block_subscriptions_into_tenant: Optional[bool] = None, exempted_principals: Optional[List[str]] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword block_subscriptions_leaving_tenant: Blocks the leaving of subscriptions from user's tenant. diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/__init__.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/__init__.py index 532abd5a6165..bfa9e7d69460 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/__init__.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/__init__.py @@ -5,27 +5,35 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +# pylint: disable=wrong-import-position -from ._subscriptions_operations import SubscriptionsOperations -from ._tenants_operations import TenantsOperations -from ._subscription_operations import SubscriptionOperations -from ._operations import Operations -from ._alias_operations import AliasOperations -from ._subscription_policy_operations import SubscriptionPolicyOperations -from ._billing_account_operations import BillingAccountOperations +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._subscriptions_operations import SubscriptionsOperations # type: ignore +from ._tenants_operations import TenantsOperations # type: ignore +from ._subscription_operations import SubscriptionOperations # type: ignore +from ._subscription_operation_operations import SubscriptionOperationOperations # type: ignore +from ._operations import Operations # type: ignore +from ._alias_operations import AliasOperations # type: ignore +from ._subscription_policy_operations import SubscriptionPolicyOperations # type: ignore +from ._billing_account_operations import BillingAccountOperations # type: ignore from ._patch import __all__ as _patch_all -from ._patch import * # pylint: disable=unused-wildcard-import +from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ "SubscriptionsOperations", "TenantsOperations", "SubscriptionOperations", + "SubscriptionOperationOperations", "Operations", "AliasOperations", "SubscriptionPolicyOperations", "BillingAccountOperations", ] -__all__.extend([p for p in _patch_all if p not in __all__]) +__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_alias_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_alias_operations.py index 07dc46d3d050..dd0593c3cab2 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_alias_operations.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_alias_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,8 +5,9 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +from typing import Any, Callable, Dict, IO, Iterator, Optional, TypeVar, Union, cast, overload from azure.core.exceptions import ( ClientAuthenticationError, @@ -15,12 +15,13 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import HttpResponse from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest +from azure.core.rest import HttpRequest, HttpResponse from azure.core.tracing.decorator import distributed_trace from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat @@ -28,12 +29,11 @@ from .. import models as _models from .._serialization import Serializer -from .._vendor import _convert_request, _format_url_section -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -45,7 +45,7 @@ def build_create_request(alias_name: str, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -55,7 +55,7 @@ def build_create_request(alias_name: str, **kwargs: Any) -> HttpRequest: "aliasName": _SERIALIZER.url("alias_name", alias_name, "str"), } - _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -72,7 +72,7 @@ def build_get_request(alias_name: str, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -81,7 +81,7 @@ def build_get_request(alias_name: str, **kwargs: Any) -> HttpRequest: "aliasName": _SERIALIZER.url("alias_name", alias_name, "str"), } - _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -96,7 +96,7 @@ def build_delete_request(alias_name: str, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -105,7 +105,7 @@ def build_delete_request(alias_name: str, **kwargs: Any) -> HttpRequest: "aliasName": _SERIALIZER.url("alias_name", alias_name, "str"), } - _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -120,7 +120,7 @@ def build_list_request(**kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -155,9 +155,9 @@ def __init__(self, *args, **kwargs): self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") def _create_initial( - self, alias_name: str, body: Union[_models.PutAliasRequest, IO], **kwargs: Any - ) -> _models.SubscriptionAliasResponse: - error_map = { + self, alias_name: str, body: Union[_models.PutAliasRequest, IO[bytes]], **kwargs: Any + ) -> Iterator[bytes]: + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -168,55 +168,53 @@ def _create_initial( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.SubscriptionAliasResponse] = kwargs.pop("cls", None) + cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(body, (IO, bytes)): + if isinstance(body, (IOBase, bytes)): _content = body else: _json = self._serialize.body(body, "PutAliasRequest") - request = build_create_request( + _request = build_create_request( alias_name=alias_name, api_version=api_version, content_type=content_type, json=_json, content=_content, - template_url=self._create_initial.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) + _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response if response.status_code not in [200, 201]: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("SubscriptionAliasResponse", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("SubscriptionAliasResponse", pipeline_response) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore return deserialized # type: ignore - _create_initial.metadata = {"url": "/providers/Microsoft.Subscription/aliases/{aliasName}"} - @overload def begin_create( self, alias_name: str, body: _models.PutAliasRequest, *, content_type: str = "application/json", **kwargs: Any @@ -232,14 +230,6 @@ def begin_create( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :keyword str continuation_token: A continuation token to restart a poller from a saved state. - :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this - operation to not poll, or pass in your own initialized polling object for a personal polling - strategy. - :paramtype polling: bool or ~azure.core.polling.PollingMethod - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. :return: An instance of LROPoller that returns either SubscriptionAliasResponse or the result of cls(response) :rtype: @@ -249,7 +239,7 @@ def begin_create( @overload def begin_create( - self, alias_name: str, body: IO, *, content_type: str = "application/json", **kwargs: Any + self, alias_name: str, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any ) -> LROPoller[_models.SubscriptionAliasResponse]: """Create Alias Subscription. @@ -258,18 +248,10 @@ def begin_create( request for subscription creation. Required. :type alias_name: str :param body: Required. - :type body: IO + :type body: IO[bytes] :keyword content_type: Body Parameter content-type. Content type parameter for binary body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :keyword str continuation_token: A continuation token to restart a poller from a saved state. - :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this - operation to not poll, or pass in your own initialized polling object for a personal polling - strategy. - :paramtype polling: bool or ~azure.core.polling.PollingMethod - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. :return: An instance of LROPoller that returns either SubscriptionAliasResponse or the result of cls(response) :rtype: @@ -279,7 +261,7 @@ def begin_create( @distributed_trace def begin_create( - self, alias_name: str, body: Union[_models.PutAliasRequest, IO], **kwargs: Any + self, alias_name: str, body: Union[_models.PutAliasRequest, IO[bytes]], **kwargs: Any ) -> LROPoller[_models.SubscriptionAliasResponse]: """Create Alias Subscription. @@ -287,19 +269,8 @@ def begin_create( is not the same as subscription name and this doesn’t have any other lifecycle need beyond the request for subscription creation. Required. :type alias_name: str - :param body: Is either a model type or a IO type. Required. - :type body: ~azure.mgmt.subscription.models.PutAliasRequest or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :keyword str continuation_token: A continuation token to restart a poller from a saved state. - :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this - operation to not poll, or pass in your own initialized polling object for a personal polling - strategy. - :paramtype polling: bool or ~azure.core.polling.PollingMethod - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. + :param body: Is either a PutAliasRequest type or a IO[bytes] type. Required. + :type body: ~azure.mgmt.subscription.models.PutAliasRequest or IO[bytes] :return: An instance of LROPoller that returns either SubscriptionAliasResponse or the result of cls(response) :rtype: @@ -309,7 +280,7 @@ def begin_create( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.SubscriptionAliasResponse] = kwargs.pop("cls", None) polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) @@ -326,12 +297,13 @@ def begin_create( params=_params, **kwargs ) + raw_result.http_response.read() # type: ignore kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize("SubscriptionAliasResponse", pipeline_response) + deserialized = self._deserialize("SubscriptionAliasResponse", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore return deserialized if polling is True: @@ -341,15 +313,15 @@ def get_long_running_output(pipeline_response): else: polling_method = polling if cont_token: - return LROPoller.from_continuation_token( + return LROPoller[_models.SubscriptionAliasResponse].from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, deserialization_callback=get_long_running_output, ) - return LROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - begin_create.metadata = {"url": "/providers/Microsoft.Subscription/aliases/{aliasName}"} + return LROPoller[_models.SubscriptionAliasResponse]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) @distributed_trace def get(self, alias_name: str, **kwargs: Any) -> _models.SubscriptionAliasResponse: @@ -359,12 +331,11 @@ def get(self, alias_name: str, **kwargs: Any) -> _models.SubscriptionAliasRespon is not the same as subscription name and this doesn’t have any other lifecycle need beyond the request for subscription creation. Required. :type alias_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: SubscriptionAliasResponse or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.SubscriptionAliasResponse :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -375,21 +346,20 @@ def get(self, alias_name: str, **kwargs: Any) -> _models.SubscriptionAliasRespon _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.SubscriptionAliasResponse] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( alias_name=alias_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) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -399,14 +369,12 @@ def get(self, alias_name: str, **kwargs: Any) -> _models.SubscriptionAliasRespon error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("SubscriptionAliasResponse", pipeline_response) + deserialized = self._deserialize("SubscriptionAliasResponse", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - get.metadata = {"url": "/providers/Microsoft.Subscription/aliases/{aliasName}"} + return deserialized # type: ignore @distributed_trace def delete(self, alias_name: str, **kwargs: Any) -> None: # pylint: disable=inconsistent-return-statements @@ -416,12 +384,11 @@ def delete(self, alias_name: str, **kwargs: Any) -> None: # pylint: disable=inc is not the same as subscription name and this doesn’t have any other lifecycle need beyond the request for subscription creation. Required. :type alias_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: None or the result of cls(response) :rtype: None :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -432,21 +399,20 @@ def delete(self, alias_name: str, **kwargs: Any) -> None: # pylint: disable=inc _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[None] = kwargs.pop("cls", None) - request = build_delete_request( + _request = build_delete_request( alias_name=alias_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) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -457,20 +423,17 @@ def delete(self, alias_name: str, **kwargs: Any) -> None: # pylint: disable=inc raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: - return cls(pipeline_response, None, {}) - - delete.metadata = {"url": "/providers/Microsoft.Subscription/aliases/{aliasName}"} + return cls(pipeline_response, None, {}) # type: ignore @distributed_trace def list(self, **kwargs: Any) -> _models.SubscriptionAliasListResult: """List Alias Subscription. - :keyword callable cls: A custom type or function that will be passed the direct response :return: SubscriptionAliasListResult or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.SubscriptionAliasListResult :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -481,20 +444,19 @@ def list(self, **kwargs: Any) -> _models.SubscriptionAliasListResult: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.SubscriptionAliasListResult] = kwargs.pop("cls", None) - request = build_list_request( + _request = build_list_request( api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -504,11 +466,9 @@ def list(self, **kwargs: Any) -> _models.SubscriptionAliasListResult: error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("SubscriptionAliasListResult", pipeline_response) + deserialized = self._deserialize("SubscriptionAliasListResult", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - list.metadata = {"url": "/providers/Microsoft.Subscription/aliases"} + return deserialized # type: ignore diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_billing_account_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_billing_account_operations.py index c72c6ffb0353..f0b3b9b5058c 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_billing_account_operations.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_billing_account_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -18,20 +17,18 @@ map_error, ) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import HttpResponse -from azure.core.rest import HttpRequest +from azure.core.rest import HttpRequest, HttpResponse from azure.core.tracing.decorator import distributed_trace from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models from .._serialization import Serializer -from .._vendor import _convert_request, _format_url_section -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -43,7 +40,7 @@ def build_get_policy_request(billing_account_id: str, **kwargs: Any) -> HttpRequ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -55,7 +52,7 @@ def build_get_policy_request(billing_account_id: str, **kwargs: Any) -> HttpRequ "billingAccountId": _SERIALIZER.url("billing_account_id", billing_account_id, "str"), } - _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -91,12 +88,11 @@ def get_policy(self, billing_account_id: str, **kwargs: Any) -> _models.BillingA :param billing_account_id: Billing Account Id. Required. :type billing_account_id: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: BillingAccountPoliciesResponse or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.BillingAccountPoliciesResponse :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -107,21 +103,20 @@ def get_policy(self, billing_account_id: str, **kwargs: Any) -> _models.BillingA _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.BillingAccountPoliciesResponse] = kwargs.pop("cls", None) - request = build_get_policy_request( + _request = build_get_policy_request( billing_account_id=billing_account_id, api_version=api_version, - template_url=self.get_policy.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -131,13 +126,9 @@ def get_policy(self, billing_account_id: str, **kwargs: Any) -> _models.BillingA error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("BillingAccountPoliciesResponse", pipeline_response) + deserialized = self._deserialize("BillingAccountPoliciesResponse", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get_policy.metadata = { - "url": "/providers/Microsoft.Billing/billingAccounts/{billingAccountId}/providers/Microsoft.Subscription/policies/default" - } + return deserialized # type: ignore diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_operations.py index fb51fee6f83f..9629a47a8507 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_operations.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -19,20 +18,18 @@ ) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import HttpResponse -from azure.core.rest import HttpRequest +from azure.core.rest import HttpRequest, HttpResponse from azure.core.tracing.decorator import distributed_trace from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models from .._serialization import Serializer -from .._vendor import _convert_request -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -44,7 +41,7 @@ def build_list_request(**kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -82,7 +79,6 @@ def __init__(self, *args, **kwargs): def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: """Lists all of the available Microsoft.Subscription API operations. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either Operation or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.subscription.models.Operation] :raises ~azure.core.exceptions.HttpResponseError: @@ -90,10 +86,10 @@ def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -104,21 +100,18 @@ def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: - request = HttpRequest("GET", next_link) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request = HttpRequest("GET", next_link) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request def extract_data(pipeline_response): deserialized = self._deserialize("OperationListResult", pipeline_response) @@ -128,10 +121,11 @@ def extract_data(pipeline_response): return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -143,5 +137,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list.metadata = {"url": "/providers/Microsoft.Subscription/operations"} diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscription_operation_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscription_operation_operations.py new file mode 100644 index 000000000000..6347518bfc98 --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscription_operation_operations.py @@ -0,0 +1,139 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import sys +from typing import Any, Callable, Dict, Optional, TypeVar + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) +from azure.core.pipeline import PipelineResponse +from azure.core.rest import HttpRequest, HttpResponse +from azure.core.tracing.decorator import distributed_trace +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat + +from .. import models as _models +from .._serialization import Serializer + +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping +else: + from typing import MutableMapping # type: ignore +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_get_request(operation_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/providers/Microsoft.Subscription/subscriptionOperations/{operationId}") + path_format_arguments = { + "operationId": _SERIALIZER.url("operation_id", operation_id, "str"), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +class SubscriptionOperationOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.subscription.SubscriptionClient`'s + :attr:`subscription_operation` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs): + input_args = list(args) + self._client = input_args.pop(0) if input_args else kwargs.pop("client") + self._config = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def get(self, operation_id: str, **kwargs: Any) -> Optional[_models.SubscriptionCreationResult]: + """Get the status of the pending Microsoft.Subscription API operations. + + :param operation_id: The operation ID, which can be found from the Location field in the + generate recommendation response header. Required. + :type operation_id: str + :return: SubscriptionCreationResult or None or the result of cls(response) + :rtype: ~azure.mgmt.subscription.models.SubscriptionCreationResult or None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + cls: ClsType[Optional[_models.SubscriptionCreationResult]] = kwargs.pop("cls", None) + + _request = build_get_request( + operation_id=operation_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = None + response_headers = {} + if response.status_code == 200: + deserialized = self._deserialize("SubscriptionCreationResult", pipeline_response.http_response) + + if response.status_code == 202: + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscription_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscription_operations.py index bbea1fe2c189..b0295017e957 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscription_operations.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscription_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,8 +5,9 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +from io import IOBase import sys -from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +from typing import Any, Callable, Dict, IO, Iterator, Optional, TypeVar, Union, cast, overload from azure.core.exceptions import ( ClientAuthenticationError, @@ -15,12 +15,13 @@ ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import HttpResponse from azure.core.polling import LROPoller, NoPolling, PollingMethod -from azure.core.rest import HttpRequest +from azure.core.rest import HttpRequest, HttpResponse from azure.core.tracing.decorator import distributed_trace from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat @@ -28,12 +29,11 @@ from .. import models as _models from .._serialization import Serializer -from .._vendor import _convert_request, _format_url_section -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -45,7 +45,7 @@ def build_cancel_request(subscription_id: str, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -54,7 +54,7 @@ def build_cancel_request(subscription_id: str, **kwargs: Any) -> HttpRequest: "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -69,7 +69,7 @@ def build_rename_request(subscription_id: str, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -79,7 +79,7 @@ def build_rename_request(subscription_id: str, **kwargs: Any) -> HttpRequest: "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -96,7 +96,7 @@ def build_enable_request(subscription_id: str, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -105,7 +105,7 @@ def build_enable_request(subscription_id: str, **kwargs: Any) -> HttpRequest: "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -120,7 +120,7 @@ def build_accept_ownership_request(subscription_id: str, **kwargs: Any) -> HttpR _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -132,7 +132,7 @@ def build_accept_ownership_request(subscription_id: str, **kwargs: Any) -> HttpR "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -149,7 +149,7 @@ def build_accept_ownership_status_request(subscription_id: str, **kwargs: Any) - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -160,7 +160,7 @@ def build_accept_ownership_status_request(subscription_id: str, **kwargs: Any) - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -196,12 +196,11 @@ def cancel(self, subscription_id: str, **kwargs: Any) -> _models.CanceledSubscri :param subscription_id: Subscription Id. Required. :type subscription_id: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: CanceledSubscriptionId or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.CanceledSubscriptionId :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -212,21 +211,20 @@ def cancel(self, subscription_id: str, **kwargs: Any) -> _models.CanceledSubscri _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.CanceledSubscriptionId] = kwargs.pop("cls", None) - request = build_cancel_request( + _request = build_cancel_request( subscription_id=subscription_id, api_version=api_version, - template_url=self.cancel.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -236,14 +234,12 @@ def cancel(self, subscription_id: str, **kwargs: Any) -> _models.CanceledSubscri error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("CanceledSubscriptionId", pipeline_response) + deserialized = self._deserialize("CanceledSubscriptionId", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - cancel.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Subscription/cancel"} + return deserialized # type: ignore @overload def rename( @@ -263,7 +259,6 @@ def rename( :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: RenamedSubscriptionId or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.RenamedSubscriptionId :raises ~azure.core.exceptions.HttpResponseError: @@ -271,18 +266,17 @@ def rename( @overload def rename( - self, subscription_id: str, body: IO, *, content_type: str = "application/json", **kwargs: Any + self, subscription_id: str, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any ) -> _models.RenamedSubscriptionId: """The operation to rename a subscription. :param subscription_id: Subscription Id. Required. :type subscription_id: str :param body: Subscription Name. Required. - :type body: IO + :type body: IO[bytes] :keyword content_type: Body Parameter content-type. Content type parameter for binary body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: RenamedSubscriptionId or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.RenamedSubscriptionId :raises ~azure.core.exceptions.HttpResponseError: @@ -290,23 +284,20 @@ def rename( @distributed_trace def rename( - self, subscription_id: str, body: Union[_models.SubscriptionName, IO], **kwargs: Any + self, subscription_id: str, body: Union[_models.SubscriptionName, IO[bytes]], **kwargs: Any ) -> _models.RenamedSubscriptionId: """The operation to rename a subscription. :param subscription_id: Subscription Id. Required. :type subscription_id: str - :param body: Subscription Name. Is either a model type or a IO type. Required. - :type body: ~azure.mgmt.subscription.models.SubscriptionName or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response + :param body: Subscription Name. Is either a SubscriptionName type or a IO[bytes] type. + Required. + :type body: ~azure.mgmt.subscription.models.SubscriptionName or IO[bytes] :return: RenamedSubscriptionId or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.RenamedSubscriptionId :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -317,33 +308,32 @@ def rename( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.RenamedSubscriptionId] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(body, (IO, bytes)): + if isinstance(body, (IOBase, bytes)): _content = body else: _json = self._serialize.body(body, "SubscriptionName") - request = build_rename_request( + _request = build_rename_request( subscription_id=subscription_id, api_version=api_version, content_type=content_type, json=_json, content=_content, - template_url=self.rename.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -353,14 +343,12 @@ def rename( error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("RenamedSubscriptionId", pipeline_response) + deserialized = self._deserialize("RenamedSubscriptionId", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - rename.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Subscription/rename"} + return deserialized # type: ignore @distributed_trace def enable(self, subscription_id: str, **kwargs: Any) -> _models.EnabledSubscriptionId: @@ -368,12 +356,11 @@ def enable(self, subscription_id: str, **kwargs: Any) -> _models.EnabledSubscrip :param subscription_id: Subscription Id. Required. :type subscription_id: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: EnabledSubscriptionId or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.EnabledSubscriptionId :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -384,21 +371,20 @@ def enable(self, subscription_id: str, **kwargs: Any) -> _models.EnabledSubscrip _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.EnabledSubscriptionId] = kwargs.pop("cls", None) - request = build_enable_request( + _request = build_enable_request( subscription_id=subscription_id, api_version=api_version, - template_url=self.enable.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -408,19 +394,17 @@ def enable(self, subscription_id: str, **kwargs: Any) -> _models.EnabledSubscrip error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("EnabledSubscriptionId", pipeline_response) + deserialized = self._deserialize("EnabledSubscriptionId", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized + return deserialized # type: ignore - enable.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Subscription/enable"} - - def _accept_ownership_initial( # pylint: disable=inconsistent-return-statements - self, subscription_id: str, body: Union[_models.AcceptOwnershipRequest, IO], **kwargs: Any - ) -> None: - error_map = { + def _accept_ownership_initial( + self, subscription_id: str, body: Union[_models.AcceptOwnershipRequest, IO[bytes]], **kwargs: Any + ) -> Iterator[bytes]: + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -431,38 +415,42 @@ def _accept_ownership_initial( # pylint: disable=inconsistent-return-statements _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[None] = kwargs.pop("cls", None) + cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(body, (IO, bytes)): + if isinstance(body, (IOBase, bytes)): _content = body else: _json = self._serialize.body(body, "AcceptOwnershipRequest") - request = build_accept_ownership_request( + _request = build_accept_ownership_request( subscription_id=subscription_id, api_version=api_version, content_type=content_type, json=_json, content=_content, - template_url=self._accept_ownership_initial.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _decompress = kwargs.pop("decompress", True) + _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response if response.status_code not in [202]: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) @@ -471,12 +459,12 @@ def _accept_ownership_initial( # pylint: disable=inconsistent-return-statements response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + if cls: - return cls(pipeline_response, None, response_headers) + return cls(pipeline_response, deserialized, response_headers) # type: ignore - _accept_ownership_initial.metadata = { - "url": "/providers/Microsoft.Subscription/subscriptions/{subscriptionId}/acceptOwnership" - } + return deserialized # type: ignore @overload def begin_accept_ownership( @@ -496,14 +484,6 @@ def begin_accept_ownership( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :keyword str continuation_token: A continuation token to restart a poller from a saved state. - :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this - operation to not poll, or pass in your own initialized polling object for a personal polling - strategy. - :paramtype polling: bool or ~azure.core.polling.PollingMethod - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. :return: An instance of LROPoller that returns either None or the result of cls(response) :rtype: ~azure.core.polling.LROPoller[None] :raises ~azure.core.exceptions.HttpResponseError: @@ -511,25 +491,17 @@ def begin_accept_ownership( @overload def begin_accept_ownership( - self, subscription_id: str, body: IO, *, content_type: str = "application/json", **kwargs: Any + self, subscription_id: str, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any ) -> LROPoller[None]: """Accept subscription ownership. :param subscription_id: Subscription Id. Required. :type subscription_id: str :param body: Required. - :type body: IO + :type body: IO[bytes] :keyword content_type: Body Parameter content-type. Content type parameter for binary body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :keyword str continuation_token: A continuation token to restart a poller from a saved state. - :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this - operation to not poll, or pass in your own initialized polling object for a personal polling - strategy. - :paramtype polling: bool or ~azure.core.polling.PollingMethod - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. :return: An instance of LROPoller that returns either None or the result of cls(response) :rtype: ~azure.core.polling.LROPoller[None] :raises ~azure.core.exceptions.HttpResponseError: @@ -537,25 +509,14 @@ def begin_accept_ownership( @distributed_trace def begin_accept_ownership( - self, subscription_id: str, body: Union[_models.AcceptOwnershipRequest, IO], **kwargs: Any + self, subscription_id: str, body: Union[_models.AcceptOwnershipRequest, IO[bytes]], **kwargs: Any ) -> LROPoller[None]: """Accept subscription ownership. :param subscription_id: Subscription Id. Required. :type subscription_id: str - :param body: Is either a model type or a IO type. Required. - :type body: ~azure.mgmt.subscription.models.AcceptOwnershipRequest or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :keyword str continuation_token: A continuation token to restart a poller from a saved state. - :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this - operation to not poll, or pass in your own initialized polling object for a personal polling - strategy. - :paramtype polling: bool or ~azure.core.polling.PollingMethod - :keyword int polling_interval: Default waiting time between two polls for LRO operations if no - Retry-After header is present. + :param body: Is either a AcceptOwnershipRequest type or a IO[bytes] type. Required. + :type body: ~azure.mgmt.subscription.models.AcceptOwnershipRequest or IO[bytes] :return: An instance of LROPoller that returns either None or the result of cls(response) :rtype: ~azure.core.polling.LROPoller[None] :raises ~azure.core.exceptions.HttpResponseError: @@ -563,14 +524,14 @@ def begin_accept_ownership( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[None] = kwargs.pop("cls", None) polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: - raw_result = self._accept_ownership_initial( # type: ignore + raw_result = self._accept_ownership_initial( subscription_id=subscription_id, body=body, api_version=api_version, @@ -580,11 +541,12 @@ def begin_accept_ownership( params=_params, **kwargs ) + raw_result.http_response.read() # type: ignore kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: - return cls(pipeline_response, None, {}) + return cls(pipeline_response, None, {}) # type: ignore if polling is True: polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) @@ -593,17 +555,13 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- else: polling_method = polling if cont_token: - return LROPoller.from_continuation_token( + return LROPoller[None].from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, deserialization_callback=get_long_running_output, ) - return LROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - begin_accept_ownership.metadata = { - "url": "/providers/Microsoft.Subscription/subscriptions/{subscriptionId}/acceptOwnership" - } + return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore @distributed_trace def accept_ownership_status(self, subscription_id: str, **kwargs: Any) -> _models.AcceptOwnershipStatusResponse: @@ -611,12 +569,11 @@ def accept_ownership_status(self, subscription_id: str, **kwargs: Any) -> _model :param subscription_id: Subscription Id. Required. :type subscription_id: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: AcceptOwnershipStatusResponse or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.AcceptOwnershipStatusResponse :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -627,21 +584,20 @@ def accept_ownership_status(self, subscription_id: str, **kwargs: Any) -> _model _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.AcceptOwnershipStatusResponse] = kwargs.pop("cls", None) - request = build_accept_ownership_status_request( + _request = build_accept_ownership_status_request( subscription_id=subscription_id, api_version=api_version, - template_url=self.accept_ownership_status.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -651,13 +607,9 @@ def accept_ownership_status(self, subscription_id: str, **kwargs: Any) -> _model error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("AcceptOwnershipStatusResponse", pipeline_response) + deserialized = self._deserialize("AcceptOwnershipStatusResponse", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - accept_ownership_status.metadata = { - "url": "/providers/Microsoft.Subscription/subscriptions/{subscriptionId}/acceptOwnershipStatus" - } + return deserialized # type: ignore diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscription_policy_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscription_policy_operations.py index 8e7ce54425dc..6e1e921885f8 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscription_policy_operations.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscription_policy_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,6 +5,7 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +from io import IOBase import sys from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload @@ -19,20 +19,18 @@ ) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import HttpResponse -from azure.core.rest import HttpRequest +from azure.core.rest import HttpRequest, HttpResponse from azure.core.tracing.decorator import distributed_trace from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models from .._serialization import Serializer -from .._vendor import _convert_request -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -40,11 +38,11 @@ _SERIALIZER.client_side_validation = False -def build_add_update_policy_for_tenant_request(**kwargs: Any) -> HttpRequest: +def build_add_update_policy_for_tenant_request(**kwargs: Any) -> HttpRequest: # pylint: disable=name-too-long _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -66,7 +64,7 @@ def build_get_policy_for_tenant_request(**kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -85,7 +83,7 @@ def build_list_policy_for_tenant_request(**kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -130,7 +128,6 @@ def add_update_policy_for_tenant( :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: GetTenantPolicyResponse or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.GetTenantPolicyResponse :raises ~azure.core.exceptions.HttpResponseError: @@ -138,16 +135,15 @@ def add_update_policy_for_tenant( @overload def add_update_policy_for_tenant( - self, body: IO, *, content_type: str = "application/json", **kwargs: Any + self, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any ) -> _models.GetTenantPolicyResponse: """Create or Update Subscription tenant policy for user's tenant. :param body: Required. - :type body: IO + :type body: IO[bytes] :keyword content_type: Body Parameter content-type. Content type parameter for binary body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: GetTenantPolicyResponse or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.GetTenantPolicyResponse :raises ~azure.core.exceptions.HttpResponseError: @@ -155,21 +151,17 @@ def add_update_policy_for_tenant( @distributed_trace def add_update_policy_for_tenant( - self, body: Union[_models.PutTenantPolicyRequestProperties, IO], **kwargs: Any + self, body: Union[_models.PutTenantPolicyRequestProperties, IO[bytes]], **kwargs: Any ) -> _models.GetTenantPolicyResponse: """Create or Update Subscription tenant policy for user's tenant. - :param body: Is either a model type or a IO type. Required. - :type body: ~azure.mgmt.subscription.models.PutTenantPolicyRequestProperties or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response + :param body: Is either a PutTenantPolicyRequestProperties type or a IO[bytes] type. Required. + :type body: ~azure.mgmt.subscription.models.PutTenantPolicyRequestProperties or IO[bytes] :return: GetTenantPolicyResponse or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.GetTenantPolicyResponse :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -180,32 +172,31 @@ def add_update_policy_for_tenant( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) cls: ClsType[_models.GetTenantPolicyResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(body, (IO, bytes)): + if isinstance(body, (IOBase, bytes)): _content = body else: _json = self._serialize.body(body, "PutTenantPolicyRequestProperties") - request = build_add_update_policy_for_tenant_request( + _request = build_add_update_policy_for_tenant_request( api_version=api_version, content_type=content_type, json=_json, content=_content, - template_url=self.add_update_policy_for_tenant.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -215,25 +206,22 @@ def add_update_policy_for_tenant( error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("GetTenantPolicyResponse", pipeline_response) + deserialized = self._deserialize("GetTenantPolicyResponse", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - add_update_policy_for_tenant.metadata = {"url": "/providers/Microsoft.Subscription/policies/default"} + return deserialized # type: ignore @distributed_trace def get_policy_for_tenant(self, **kwargs: Any) -> _models.GetTenantPolicyResponse: """Get the subscription tenant policy for the user's tenant. - :keyword callable cls: A custom type or function that will be passed the direct response :return: GetTenantPolicyResponse or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.GetTenantPolicyResponse :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -244,20 +232,19 @@ def get_policy_for_tenant(self, **kwargs: Any) -> _models.GetTenantPolicyRespons _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.GetTenantPolicyResponse] = kwargs.pop("cls", None) - request = build_get_policy_for_tenant_request( + _request = build_get_policy_for_tenant_request( api_version=api_version, - template_url=self.get_policy_for_tenant.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -267,20 +254,17 @@ def get_policy_for_tenant(self, **kwargs: Any) -> _models.GetTenantPolicyRespons error = self._deserialize.failsafe_deserialize(_models.ErrorResponseBody, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("GetTenantPolicyResponse", pipeline_response) + deserialized = self._deserialize("GetTenantPolicyResponse", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get_policy_for_tenant.metadata = {"url": "/providers/Microsoft.Subscription/policies/default"} + return deserialized # type: ignore @distributed_trace def list_policy_for_tenant(self, **kwargs: Any) -> Iterable["_models.GetTenantPolicyResponse"]: """Get the subscription tenant policy for the user's tenant. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either GetTenantPolicyResponse or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.subscription.models.GetTenantPolicyResponse] @@ -289,10 +273,10 @@ def list_policy_for_tenant(self, **kwargs: Any) -> Iterable["_models.GetTenantPo _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2021-10-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2021-10-01")) cls: ClsType[_models.GetTenantPolicyListResponse] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -303,21 +287,18 @@ def list_policy_for_tenant(self, **kwargs: Any) -> Iterable["_models.GetTenantPo def prepare_request(next_link=None): if not next_link: - request = build_list_policy_for_tenant_request( + _request = build_list_policy_for_tenant_request( api_version=api_version, - template_url=self.list_policy_for_tenant.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: - request = HttpRequest("GET", next_link) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request = HttpRequest("GET", next_link) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request def extract_data(pipeline_response): deserialized = self._deserialize("GetTenantPolicyListResponse", pipeline_response) @@ -327,10 +308,11 @@ def extract_data(pipeline_response): return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -342,5 +324,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list_policy_for_tenant.metadata = {"url": "/providers/Microsoft.Subscription/policies"} diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscriptions_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscriptions_operations.py index 7157c104c13b..f73d405538d4 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscriptions_operations.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_subscriptions_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -19,20 +18,18 @@ ) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import HttpResponse -from azure.core.rest import HttpRequest +from azure.core.rest import HttpRequest, HttpResponse from azure.core.tracing.decorator import distributed_trace from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models from .._serialization import Serializer -from .._vendor import _convert_request, _format_url_section -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -44,7 +41,7 @@ def build_list_locations_request(subscription_id: str, **kwargs: Any) -> HttpReq _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2016-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -53,7 +50,7 @@ def build_list_locations_request(subscription_id: str, **kwargs: Any) -> HttpReq "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -68,7 +65,7 @@ def build_get_request(subscription_id: str, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2016-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -77,7 +74,7 @@ def build_get_request(subscription_id: str, **kwargs: Any) -> HttpRequest: "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -92,7 +89,7 @@ def build_list_request(**kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2016-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -135,7 +132,6 @@ def list_locations(self, subscription_id: str, **kwargs: Any) -> Iterable["_mode :param subscription_id: The ID of the target subscription. Required. :type subscription_id: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either Location or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.subscription.models.Location] :raises ~azure.core.exceptions.HttpResponseError: @@ -143,10 +139,10 @@ def list_locations(self, subscription_id: str, **kwargs: Any) -> Iterable["_mode _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2016-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) cls: ClsType[_models.LocationListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -157,22 +153,19 @@ def list_locations(self, subscription_id: str, **kwargs: Any) -> Iterable["_mode def prepare_request(next_link=None): if not next_link: - request = build_list_locations_request( + _request = build_list_locations_request( subscription_id=subscription_id, api_version=api_version, - template_url=self.list_locations.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: - request = HttpRequest("GET", next_link) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request = HttpRequest("GET", next_link) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request def extract_data(pipeline_response): deserialized = self._deserialize("LocationListResult", pipeline_response) @@ -182,10 +175,11 @@ def extract_data(pipeline_response): return None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -197,20 +191,17 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_locations.metadata = {"url": "/subscriptions/{subscriptionId}/locations"} - @distributed_trace def get(self, subscription_id: str, **kwargs: Any) -> _models.Subscription: """Gets details about a specified subscription. :param subscription_id: The ID of the target subscription. Required. :type subscription_id: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: Subscription or the result of cls(response) :rtype: ~azure.mgmt.subscription.models.Subscription :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -221,21 +212,20 @@ def get(self, subscription_id: str, **kwargs: Any) -> _models.Subscription: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2016-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) cls: ClsType[_models.Subscription] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( subscription_id=subscription_id, api_version=api_version, - template_url=self.get.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -244,20 +234,17 @@ def get(self, subscription_id: str, **kwargs: Any) -> _models.Subscription: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - deserialized = self._deserialize("Subscription", pipeline_response) + deserialized = self._deserialize("Subscription", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - get.metadata = {"url": "/subscriptions/{subscriptionId}"} + return deserialized # type: ignore @distributed_trace def list(self, **kwargs: Any) -> Iterable["_models.Subscription"]: """Gets all subscriptions for a tenant. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either Subscription or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.subscription.models.Subscription] :raises ~azure.core.exceptions.HttpResponseError: @@ -265,10 +252,10 @@ def list(self, **kwargs: Any) -> Iterable["_models.Subscription"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2016-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) cls: ClsType[_models.SubscriptionListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -279,21 +266,18 @@ def list(self, **kwargs: Any) -> Iterable["_models.Subscription"]: def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: - request = HttpRequest("GET", next_link) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request = HttpRequest("GET", next_link) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request def extract_data(pipeline_response): deserialized = self._deserialize("SubscriptionListResult", pipeline_response) @@ -303,10 +287,11 @@ def extract_data(pipeline_response): return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -317,5 +302,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions"} diff --git a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_tenants_operations.py b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_tenants_operations.py index adc5c6116e4d..58d7769c30cd 100644 --- a/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_tenants_operations.py +++ b/sdk/subscription/azure-mgmt-subscription/azure/mgmt/subscription/operations/_tenants_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -19,20 +18,18 @@ ) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import HttpResponse -from azure.core.rest import HttpRequest +from azure.core.rest import HttpRequest, HttpResponse from azure.core.tracing.decorator import distributed_trace from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models from .._serialization import Serializer -from .._vendor import _convert_request -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports + from typing import MutableMapping # type: ignore T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -44,7 +41,7 @@ def build_list_request(**kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2016-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -82,7 +79,6 @@ def __init__(self, *args, **kwargs): def list(self, **kwargs: Any) -> Iterable["_models.TenantIdDescription"]: """Gets the tenants for your account. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either TenantIdDescription or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.subscription.models.TenantIdDescription] :raises ~azure.core.exceptions.HttpResponseError: @@ -90,10 +86,10 @@ def list(self, **kwargs: Any) -> Iterable["_models.TenantIdDescription"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: Literal["2016-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2016-06-01")) cls: ClsType[_models.TenantListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -104,21 +100,18 @@ def list(self, **kwargs: Any) -> Iterable["_models.TenantIdDescription"]: def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: - request = HttpRequest("GET", next_link) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request = HttpRequest("GET", next_link) + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request def extract_data(pipeline_response): deserialized = self._deserialize("TenantListResult", pipeline_response) @@ -128,10 +121,11 @@ def extract_data(pipeline_response): return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) + _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=False, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -142,5 +136,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list.metadata = {"url": "/tenants"} diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/accept_ownership_status.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/accept_ownership_status.py index 5770cdf268a4..fd4f933b2252 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/accept_ownership_status.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/accept_ownership_status.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/accept_subscription_ownership.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/accept_subscription_ownership.py index ac6a68c4df75..62c07724b3ee 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/accept_subscription_ownership.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/accept_subscription_ownership.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ @@ -28,7 +29,7 @@ def main(): credential=DefaultAzureCredential(), ) - response = client.subscription.begin_accept_ownership( + client.subscription.begin_accept_ownership( subscription_id="291bba3f-e0a5-47bc-a099-3bdcb2a50a05", body={ "properties": { @@ -38,7 +39,6 @@ def main(): } }, ).result() - print(response) # x-ms-original-file: specification/subscription/resource-manager/Microsoft.Subscription/stable/2021-10-01/examples/acceptSubscriptionOwnership.json diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/cancel_subscription.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/cancel_subscription.py index 410f74d8c497..d3a6cee576eb 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/cancel_subscription.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/cancel_subscription.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/change_tenant_policy.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/change_tenant_policy.py index 091f80069224..4630fdfb3e95 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/change_tenant_policy.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/change_tenant_policy.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/create_alias.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/create_alias.py index 6c0fc1e5df6a..71e04a1e8386 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/create_alias.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/create_alias.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/delete_alias.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/delete_alias.py index d8a6ad618c7c..9dec9f6b821b 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/delete_alias.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/delete_alias.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ @@ -28,10 +29,9 @@ def main(): credential=DefaultAzureCredential(), ) - response = client.alias.delete( + client.alias.delete( alias_name="aliasForNewSub", ) - print(response) # x-ms-original-file: specification/subscription/resource-manager/Microsoft.Subscription/stable/2021-10-01/examples/deleteAlias.json diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/enable_subscription.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/enable_subscription.py index 42b40a43a9bd..4f9604e9f6cc 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/enable_subscription.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/enable_subscription.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/get_alias.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/get_alias.py index 7e2e8070fc00..027e36ecc89a 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/get_alias.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/get_alias.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/get_billing_account_policy.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/get_billing_account_policy.py index fffd4fa1f741..915050223dd5 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/get_billing_account_policy.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/get_billing_account_policy.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/get_operations.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/get_operations.py index cd9fb2119232..51771ae8ee8a 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/get_operations.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/get_operations.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/get_subscription.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/get_subscription.py index 777eb820c30c..746351a466f5 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/get_subscription.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/get_subscription.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/get_subscription_operation.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/get_subscription_operation.py new file mode 100644 index 000000000000..9c2d631c590e --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/get_subscription_operation.py @@ -0,0 +1,40 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from azure.identity import DefaultAzureCredential + +from azure.mgmt.subscription import SubscriptionClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-subscription +# USAGE + python get_subscription_operation.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = SubscriptionClient( + credential=DefaultAzureCredential(), + ) + + response = client.subscription_operation.get( + operation_id="e4b8d068-f574-462a-a76f-6fa0afc613c9", + ) + print(response) + + +# x-ms-original-file: specification/subscription/resource-manager/Microsoft.Subscription/stable/2021-10-01/examples/getSubscriptionOperation.json +if __name__ == "__main__": + main() diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/get_tenant_policy.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/get_tenant_policy.py index 3042d9fd1e6b..f3c075162797 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/get_tenant_policy.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/get_tenant_policy.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/get_tenant_policy_list.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/get_tenant_policy_list.py index b6708e3e1c6a..86758ae84648 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/get_tenant_policy_list.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/get_tenant_policy_list.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/list_alias.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/list_alias.py index 6d39fd3f13b1..c5002f0adbd9 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/list_alias.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/list_alias.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/list_locations.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/list_locations.py index f814ca35b038..3d4434ecad65 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/list_locations.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/list_locations.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/list_subscriptions.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/list_subscriptions.py index b6ac8367279c..29e57f933999 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/list_subscriptions.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/list_subscriptions.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/list_tenants.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/list_tenants.py index 97f77b668ff4..beef5c69d7b1 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/list_tenants.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/list_tenants.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_samples/rename_subscription.py b/sdk/subscription/azure-mgmt-subscription/generated_samples/rename_subscription.py index 1dac3b15dbb5..552c86cee73c 100644 --- a/sdk/subscription/azure-mgmt-subscription/generated_samples/rename_subscription.py +++ b/sdk/subscription/azure-mgmt-subscription/generated_samples/rename_subscription.py @@ -7,6 +7,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.subscription import SubscriptionClient """ diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/conftest.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/conftest.py new file mode 100644 index 000000000000..3a655a68c15d --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/conftest.py @@ -0,0 +1,35 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import os +import pytest +from dotenv import load_dotenv +from devtools_testutils import ( + test_proxy, + add_general_regex_sanitizer, + add_body_key_sanitizer, + add_header_regex_sanitizer, +) + +load_dotenv() + + +# For security, please avoid record sensitive identity information in recordings +@pytest.fixture(scope="session", autouse=True) +def add_sanitizers(test_proxy): + subscription_subscription_id = os.environ.get("AZURE_SUBSCRIPTION_ID", "00000000-0000-0000-0000-000000000000") + subscription_tenant_id = os.environ.get("AZURE_TENANT_ID", "00000000-0000-0000-0000-000000000000") + subscription_client_id = os.environ.get("AZURE_CLIENT_ID", "00000000-0000-0000-0000-000000000000") + subscription_client_secret = os.environ.get("AZURE_CLIENT_SECRET", "00000000-0000-0000-0000-000000000000") + add_general_regex_sanitizer(regex=subscription_subscription_id, value="00000000-0000-0000-0000-000000000000") + add_general_regex_sanitizer(regex=subscription_tenant_id, value="00000000-0000-0000-0000-000000000000") + add_general_regex_sanitizer(regex=subscription_client_id, value="00000000-0000-0000-0000-000000000000") + add_general_regex_sanitizer(regex=subscription_client_secret, value="00000000-0000-0000-0000-000000000000") + + add_header_regex_sanitizer(key="Set-Cookie", value="[set-cookie;]") + add_header_regex_sanitizer(key="Cookie", value="cookie;") + add_body_key_sanitizer(json_path="$..access_token", value="access_token") diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_alias_operations.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_alias_operations.py new file mode 100644 index 000000000000..ddc5fdd43a05 --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_alias_operations.py @@ -0,0 +1,71 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionAliasOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_alias_begin_create(self, resource_group): + response = self.client.alias.begin_create( + alias_name="str", + body={ + "properties": { + "billingScope": "str", + "displayName": "str", + "resellerId": "str", + "subscriptionId": "str", + "workload": "str", + } + }, + api_version="2021-10-01", + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_alias_get(self, resource_group): + response = self.client.alias.get( + alias_name="str", + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_alias_delete(self, resource_group): + response = self.client.alias.delete( + alias_name="str", + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_alias_list(self, resource_group): + response = self.client.alias.list( + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_alias_operations_async.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_alias_operations_async.py new file mode 100644 index 000000000000..3addfeab1435 --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_alias_operations_async.py @@ -0,0 +1,74 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription.aio import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionAliasOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_alias_begin_create(self, resource_group): + response = await ( + await self.client.alias.begin_create( + alias_name="str", + body={ + "properties": { + "billingScope": "str", + "displayName": "str", + "resellerId": "str", + "subscriptionId": "str", + "workload": "str", + } + }, + api_version="2021-10-01", + ) + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_alias_get(self, resource_group): + response = await self.client.alias.get( + alias_name="str", + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_alias_delete(self, resource_group): + response = await self.client.alias.delete( + alias_name="str", + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_alias_list(self, resource_group): + response = await self.client.alias.list( + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_billing_account_operations.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_billing_account_operations.py new file mode 100644 index 000000000000..71ba8133d4a7 --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_billing_account_operations.py @@ -0,0 +1,30 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionBillingAccountOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_billing_account_get_policy(self, resource_group): + response = self.client.billing_account.get_policy( + billing_account_id="str", + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_billing_account_operations_async.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_billing_account_operations_async.py new file mode 100644 index 000000000000..b3f3dca4e91f --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_billing_account_operations_async.py @@ -0,0 +1,31 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription.aio import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionBillingAccountOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_billing_account_get_policy(self, resource_group): + response = await self.client.billing_account.get_policy( + billing_account_id="str", + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_operations.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_operations.py new file mode 100644 index 000000000000..14bff9c101cb --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_operations.py @@ -0,0 +1,29 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_operations_list(self, resource_group): + response = self.client.operations.list( + api_version="2021-10-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_operations_async.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_operations_async.py new file mode 100644 index 000000000000..14d40c348579 --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_operations_async.py @@ -0,0 +1,30 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription.aio import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_operations_list(self, resource_group): + response = self.client.operations.list( + api_version="2021-10-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operation_operations.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operation_operations.py new file mode 100644 index 000000000000..4d68392a1220 --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operation_operations.py @@ -0,0 +1,30 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionSubscriptionOperationOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_subscription_operation_get(self, resource_group): + response = self.client.subscription_operation.get( + operation_id="str", + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operation_operations_async.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operation_operations_async.py new file mode 100644 index 000000000000..d478c76d5f30 --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operation_operations_async.py @@ -0,0 +1,31 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription.aio import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionSubscriptionOperationOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_subscription_operation_get(self, resource_group): + response = await self.client.subscription_operation.get( + operation_id="str", + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operations.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operations.py new file mode 100644 index 000000000000..e37fe60bbdca --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operations.py @@ -0,0 +1,76 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionSubscriptionOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_subscription_cancel(self, resource_group): + response = self.client.subscription.cancel( + subscription_id="str", + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_subscription_rename(self, resource_group): + response = self.client.subscription.rename( + subscription_id="str", + body={"subscriptionName": "str"}, + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_subscription_enable(self, resource_group): + response = self.client.subscription.enable( + subscription_id="str", + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_subscription_begin_accept_ownership(self, resource_group): + response = self.client.subscription.begin_accept_ownership( + subscription_id="str", + body={"properties": {"displayName": "str", "managementGroupId": "str", "tags": {"str": "str"}}}, + api_version="2021-10-01", + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_subscription_accept_ownership_status(self, resource_group): + response = self.client.subscription.accept_ownership_status( + subscription_id="str", + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operations_async.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operations_async.py new file mode 100644 index 000000000000..5888d2e2d97f --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_operations_async.py @@ -0,0 +1,79 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription.aio import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionSubscriptionOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_subscription_cancel(self, resource_group): + response = await self.client.subscription.cancel( + subscription_id="str", + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_subscription_rename(self, resource_group): + response = await self.client.subscription.rename( + subscription_id="str", + body={"subscriptionName": "str"}, + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_subscription_enable(self, resource_group): + response = await self.client.subscription.enable( + subscription_id="str", + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_subscription_begin_accept_ownership(self, resource_group): + response = await ( + await self.client.subscription.begin_accept_ownership( + subscription_id="str", + body={"properties": {"displayName": "str", "managementGroupId": "str", "tags": {"str": "str"}}}, + api_version="2021-10-01", + ) + ).result() # call '.result()' to poll until service return final result + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_subscription_accept_ownership_status(self, resource_group): + response = await self.client.subscription.accept_ownership_status( + subscription_id="str", + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_policy_operations.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_policy_operations.py new file mode 100644 index 000000000000..7c4fe8e62672 --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_policy_operations.py @@ -0,0 +1,54 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionSubscriptionPolicyOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_subscription_policy_add_update_policy_for_tenant(self, resource_group): + response = self.client.subscription_policy.add_update_policy_for_tenant( + body={ + "blockSubscriptionsIntoTenant": bool, + "blockSubscriptionsLeavingTenant": bool, + "exemptedPrincipals": ["str"], + }, + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_subscription_policy_get_policy_for_tenant(self, resource_group): + response = self.client.subscription_policy.get_policy_for_tenant( + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_subscription_policy_list_policy_for_tenant(self, resource_group): + response = self.client.subscription_policy.list_policy_for_tenant( + api_version="2021-10-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_policy_operations_async.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_policy_operations_async.py new file mode 100644 index 000000000000..c5d54faa46a8 --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscription_policy_operations_async.py @@ -0,0 +1,55 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription.aio import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionSubscriptionPolicyOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_subscription_policy_add_update_policy_for_tenant(self, resource_group): + response = await self.client.subscription_policy.add_update_policy_for_tenant( + body={ + "blockSubscriptionsIntoTenant": bool, + "blockSubscriptionsLeavingTenant": bool, + "exemptedPrincipals": ["str"], + }, + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_subscription_policy_get_policy_for_tenant(self, resource_group): + response = await self.client.subscription_policy.get_policy_for_tenant( + api_version="2021-10-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_subscription_policy_list_policy_for_tenant(self, resource_group): + response = self.client.subscription_policy.list_policy_for_tenant( + api_version="2021-10-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscriptions_operations.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscriptions_operations.py new file mode 100644 index 000000000000..380fd9e7fb64 --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscriptions_operations.py @@ -0,0 +1,51 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionSubscriptionsOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_subscriptions_list_locations(self, resource_group): + response = self.client.subscriptions.list_locations( + subscription_id="str", + api_version="2016-06-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_subscriptions_get(self, resource_group): + response = self.client.subscriptions.get( + subscription_id="str", + api_version="2016-06-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_subscriptions_list(self, resource_group): + response = self.client.subscriptions.list( + api_version="2016-06-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscriptions_operations_async.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscriptions_operations_async.py new file mode 100644 index 000000000000..c32f61c83266 --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_subscriptions_operations_async.py @@ -0,0 +1,52 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription.aio import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionSubscriptionsOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_subscriptions_list_locations(self, resource_group): + response = self.client.subscriptions.list_locations( + subscription_id="str", + api_version="2016-06-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_subscriptions_get(self, resource_group): + response = await self.client.subscriptions.get( + subscription_id="str", + api_version="2016-06-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_subscriptions_list(self, resource_group): + response = self.client.subscriptions.list( + api_version="2016-06-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_tenants_operations.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_tenants_operations.py new file mode 100644 index 000000000000..7bab49906494 --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_tenants_operations.py @@ -0,0 +1,29 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionTenantsOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_tenants_list(self, resource_group): + response = self.client.tenants.list( + api_version="2016-06-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_tenants_operations_async.py b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_tenants_operations_async.py new file mode 100644 index 000000000000..e092b4c8eeb6 --- /dev/null +++ b/sdk/subscription/azure-mgmt-subscription/generated_tests/test_subscription_tenants_operations_async.py @@ -0,0 +1,30 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.subscription.aio import SubscriptionClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestSubscriptionTenantsOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(SubscriptionClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_tenants_list(self, resource_group): + response = self.client.tenants.list( + api_version="2016-06-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/subscription/azure-mgmt-subscription/sdk_packaging.toml b/sdk/subscription/azure-mgmt-subscription/sdk_packaging.toml index a14bd0a78b34..5874dd48c084 100644 --- a/sdk/subscription/azure-mgmt-subscription/sdk_packaging.toml +++ b/sdk/subscription/azure-mgmt-subscription/sdk_packaging.toml @@ -3,7 +3,7 @@ package_name = "azure-mgmt-subscription" package_nspkg = "azure-mgmt-nspkg" package_pprint_name = "Subscription Management" package_doc_id = "" -is_stable = false +is_stable = true is_arm = true title = "SubscriptionClient" no_sub = true diff --git a/sdk/subscription/azure-mgmt-subscription/setup.py b/sdk/subscription/azure-mgmt-subscription/setup.py index 29ea384141dc..93e3269b00be 100644 --- a/sdk/subscription/azure-mgmt-subscription/setup.py +++ b/sdk/subscription/azure-mgmt-subscription/setup.py @@ -1,10 +1,10 @@ #!/usr/bin/env python -#------------------------------------------------------------------------- +# ------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. -#-------------------------------------------------------------------------- +# -------------------------------------------------------------------------- import re import os.path @@ -16,64 +16,68 @@ PACKAGE_PPRINT_NAME = "Subscription Management" # a-b-c => a/b/c -package_folder_path = PACKAGE_NAME.replace('-', '/') +package_folder_path = PACKAGE_NAME.replace("-", "/") # a-b-c => a.b.c -namespace_name = PACKAGE_NAME.replace('-', '.') +namespace_name = PACKAGE_NAME.replace("-", ".") # Version extraction inspired from 'requests' -with open(os.path.join(package_folder_path, 'version.py') - if os.path.exists(os.path.join(package_folder_path, 'version.py')) - else os.path.join(package_folder_path, '_version.py'), 'r') as fd: - version = re.search(r'^VERSION\s*=\s*[\'"]([^\'"]*)[\'"]', - fd.read(), re.MULTILINE).group(1) +with open( + os.path.join(package_folder_path, "version.py") + if os.path.exists(os.path.join(package_folder_path, "version.py")) + else os.path.join(package_folder_path, "_version.py"), + "r", +) as fd: + version = re.search(r'^VERSION\s*=\s*[\'"]([^\'"]*)[\'"]', fd.read(), re.MULTILINE).group(1) if not version: - raise RuntimeError('Cannot find version information') + raise RuntimeError("Cannot find version information") -with open('README.md', encoding='utf-8') as f: +with open("README.md", encoding="utf-8") as f: readme = f.read() -with open('CHANGELOG.md', encoding='utf-8') as f: +with open("CHANGELOG.md", encoding="utf-8") as f: changelog = f.read() setup( name=PACKAGE_NAME, version=version, - description='Microsoft Azure {} Client Library for Python'.format(PACKAGE_PPRINT_NAME), - long_description=readme + '\n\n' + changelog, - long_description_content_type='text/markdown', - license='MIT License', - author='Microsoft Corporation', - author_email='azpysdkhelp@microsoft.com', - url='https://github.com/Azure/azure-sdk-for-python', + description="Microsoft Azure {} Client Library for Python".format(PACKAGE_PPRINT_NAME), + long_description=readme + "\n\n" + changelog, + long_description_content_type="text/markdown", + license="MIT License", + author="Microsoft Corporation", + author_email="azpysdkhelp@microsoft.com", + url="https://github.com/Azure/azure-sdk-for-python", keywords="azure, azure sdk", # update with search keywords relevant to the azure service / product classifiers=[ - 'Development Status :: 4 - Beta', - 'Programming Language :: Python', - 'Programming Language :: Python :: 3 :: Only', - 'Programming Language :: Python :: 3', - 'Programming Language :: Python :: 3.7', - 'Programming Language :: Python :: 3.8', - 'Programming Language :: Python :: 3.9', - 'Programming Language :: Python :: 3.10', - 'Programming Language :: Python :: 3.11', - 'License :: OSI Approved :: MIT License', + "Development Status :: 5 - Production/Stable", + "Programming Language :: Python", + "Programming Language :: Python :: 3 :: Only", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "License :: OSI Approved :: MIT License", ], zip_safe=False, - packages=find_packages(exclude=[ - 'tests', - # Exclude packages that will be covered by PEP420 or nspkg - 'azure', - 'azure.mgmt', - ]), + packages=find_packages( + exclude=[ + "tests", + # Exclude packages that will be covered by PEP420 or nspkg + "azure", + "azure.mgmt", + ] + ), include_package_data=True, package_data={ - 'pytyped': ['py.typed'], + "pytyped": ["py.typed"], }, install_requires=[ - "msrest>=0.7.1", - "azure-common~=1.1", - "azure-mgmt-core>=1.3.2,<2.0.0", - "typing-extensions>=4.3.0; python_version<'3.8.0'", + "isodate>=0.6.1", + "typing-extensions>=4.6.0", + "azure-common>=1.1", + "azure-mgmt-core>=1.3.2", ], - python_requires=">=3.7" + python_requires=">=3.8", )