diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/CHANGELOG.md b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/CHANGELOG.md index 401e169de2ff..8549615cee29 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/CHANGELOG.md +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/CHANGELOG.md @@ -1,5 +1,30 @@ # Release History +## 1.1.0b3 (2025-04-18) + +### Features Added + + - Model `AzureBareMetalStorageInstance` added property `identity` + - Added model `AzureBareMetalStorageInstanceBody` + - Added model `AzureBareMetalStorageInstanceIdentity` + - Added enum `ResourceIdentityType` + - Model `AzureBareMetalInstancesOperations` added method `create` + - Model `AzureBareMetalInstancesOperations` added method `delete` + - Method `AzureBareMetalInstancesOperations.begin_restart` has a new overload `def begin_restart(self: None, resource_group_name: str, azure_bare_metal_instance_name: str, force_parameter: Optional[IO[bytes]], content_type: str)` + - Method `AzureBareMetalInstancesOperations.update` has a new overload `def update(self: None, resource_group_name: str, azure_bare_metal_instance_name: str, tags_parameter: IO[bytes], content_type: str)` + - Method `AzureBareMetalInstancesOperations.create` has a new overload `def create(self: None, resource_group_name: str, azure_bare_metal_instance_name: str, request_body_parameters: AzureBareMetalInstance, content_type: str)` + - Method `AzureBareMetalInstancesOperations.create` has a new overload `def create(self: None, resource_group_name: str, azure_bare_metal_instance_name: str, request_body_parameters: IO[bytes], content_type: str)` + - Method `AzureBareMetalStorageInstancesOperations.create` has a new overload `def create(self: None, resource_group_name: str, azure_bare_metal_storage_instance_name: str, request_body_parameters: IO[bytes], content_type: str)` + - Method `AzureBareMetalStorageInstancesOperations.update` has a new overload `def update(self: None, resource_group_name: str, azure_bare_metal_storage_instance_name: str, azure_bare_metal_storage_instance_body_parameter: AzureBareMetalStorageInstanceBody, content_type: str)` + - Method `AzureBareMetalStorageInstancesOperations.update` has a new overload `def update(self: None, resource_group_name: str, azure_bare_metal_storage_instance_name: str, azure_bare_metal_storage_instance_body_parameter: IO[bytes], content_type: str)` + +### Breaking Changes + + - Method `BareMetalInfrastructureClient.__init__` parameter `base_url` changed default value from `str` to `none` + - Method `AzureBareMetalStorageInstancesOperations.update` inserted a `positional_or_keyword` parameter `azure_bare_metal_storage_instance_body_parameter` + - Method `AzureBareMetalStorageInstancesOperations.update` deleted or renamed its parameter `tags_parameter` of kind `positional_or_keyword` + - Method `AzureBareMetalStorageInstancesOperations.update` re-ordered its parameters from `['self', 'resource_group_name', 'azure_bare_metal_storage_instance_name', 'tags_parameter', 'kwargs']` to `['self', 'resource_group_name', 'azure_bare_metal_storage_instance_name', 'azure_bare_metal_storage_instance_body_parameter', 'kwargs']` + ## 1.1.0b2 (2023-10-23) ### Features Added diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/README.md b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/README.md index 931a8c4042fc..f9910737f3f7 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/README.md +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/README.md @@ -1,7 +1,7 @@ # Microsoft Azure SDK for Python This is the Microsoft Azure Bare Metal Infrastructure Management Client Library. -This package has been tested with Python 3.7+. +This package has been tested with Python 3.9+. For a more complete view of Azure libraries, see the [azure sdk python release](https://aka.ms/azsdk/python/all). ## _Disclaimer_ @@ -12,7 +12,7 @@ _Azure SDK Python packages support for Python 2.7 has ended 01 January 2022. For ### Prerequisites -- Python 3.7+ is required to use this package. +- Python 3.9+ is required to use this package. - [Azure subscription](https://azure.microsoft.com/free/) ### Install the package @@ -24,7 +24,7 @@ pip install azure-identity ### Authentication -By default, [Azure Active Directory](https://aka.ms/awps/aad) token authentication depends on correct configure of following environment variables. +By default, [Azure Active Directory](https://aka.ms/awps/aad) token authentication depends on correct configuration of the following environment variables. - `AZURE_CLIENT_ID` for Azure client ID. - `AZURE_TENANT_ID` for Azure tenant ID. diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/_meta.json b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/_meta.json index 2211aa4cad1c..a04308666d4c 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/_meta.json +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/_meta.json @@ -1,11 +1,11 @@ { - "commit": "c280892951a9e45c059132c05aace25a9c752d48", + "commit": "2e99511bfd9ef9cf31ecd616bc9c0af63dfc6808", "repository_url": "https://github.com/Azure/azure-rest-api-specs", - "autorest": "3.9.7", + "autorest": "3.10.2", "use": [ - "@autorest/python@6.7.1", - "@autorest/modelerfour@4.26.2" + "@autorest/python@6.33.0", + "@autorest/modelerfour@4.27.0" ], - "autorest_command": "autorest specification/baremetalinfrastructure/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.7.1 --use=@autorest/modelerfour@4.26.2 --version=3.9.7 --version-tolerant=False", + "autorest_command": "autorest specification/baremetalinfrastructure/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.33.0 --use=@autorest/modelerfour@4.27.0 --version=3.10.2 --version-tolerant=False", "readme": "specification/baremetalinfrastructure/resource-manager/readme.md" } \ No newline at end of file diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/__init__.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/__init__.py index bcd7a84c5abb..8b06b4c00ab8 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/__init__.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/__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 ._bare_metal_infrastructure_client import BareMetalInfrastructureClient +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._bare_metal_infrastructure_client import BareMetalInfrastructureClient # 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__ = [ "BareMetalInfrastructureClient", ] -__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/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_bare_metal_infrastructure_client.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_bare_metal_infrastructure_client.py index 8a1b4e8bc832..d61f448734db 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_bare_metal_infrastructure_client.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_bare_metal_infrastructure_client.py @@ -7,10 +7,15 @@ # -------------------------------------------------------------------------- from copy import deepcopy -from typing import Any, TYPE_CHECKING +from typing import Any, Optional, TYPE_CHECKING, cast +from typing_extensions import Self +from azure.core.pipeline import policies from azure.core.rest import HttpRequest, HttpResponse +from azure.core.settings import settings from azure.mgmt.core import ARMPipelineClient +from azure.mgmt.core.policies import ARMAutoResourceProviderRegistrationPolicy +from azure.mgmt.core.tools import get_arm_endpoints from . import models as _models from ._configuration import BareMetalInfrastructureClientConfiguration @@ -18,11 +23,10 @@ from .operations import AzureBareMetalInstancesOperations, AzureBareMetalStorageInstancesOperations, Operations if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials import TokenCredential -class BareMetalInfrastructureClient: # pylint: disable=client-accepts-api-version-keyword +class BareMetalInfrastructureClient: """The Bare Metal Infrastructure Management client. :ivar azure_bare_metal_instances: AzureBareMetalInstancesOperations operations @@ -37,9 +41,9 @@ class BareMetalInfrastructureClient: # pylint: disable=client-accepts-api-versi :type credential: ~azure.core.credentials.TokenCredential :param subscription_id: The ID of the target subscription. The value must be an UUID. Required. :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". + :param base_url: Service URL. Default value is None. :type base_url: str - :keyword api_version: Api Version. Default value is "2023-08-04-preview". Note that overriding + :keyword api_version: Api Version. Default value is "2024-08-01-preview". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str :keyword int polling_interval: Default waiting time between two polls for LRO operations if no @@ -47,16 +51,36 @@ class BareMetalInfrastructureClient: # pylint: disable=client-accepts-api-versi """ def __init__( - self, - credential: "TokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any + self, credential: "TokenCredential", subscription_id: str, base_url: Optional[str] = None, **kwargs: Any ) -> None: + _cloud = kwargs.pop("cloud_setting", None) or settings.current.azure_cloud # type: ignore + _endpoints = get_arm_endpoints(_cloud) + if not base_url: + base_url = _endpoints["resource_manager"] + credential_scopes = kwargs.pop("credential_scopes", _endpoints["credential_scopes"]) self._config = BareMetalInfrastructureClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs + credential=credential, subscription_id=subscription_id, credential_scopes=credential_scopes, **kwargs ) - self._client: ARMPipelineClient = 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=cast(str, 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) @@ -70,7 +94,7 @@ def __init__( 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 @@ -90,12 +114,12 @@ 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) -> "BareMetalInfrastructureClient": + def __enter__(self) -> Self: self._client.__enter__() return self diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_configuration.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_configuration.py index 0d2ba45fb1e1..4e23e89fd031 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_configuration.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_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 BareMetalInfrastructureClientConfiguration(Configuration): # pylint: disable=too-many-instance-attributes +class BareMetalInfrastructureClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long """Configuration for BareMetalInfrastructureClient. Note that all parameters used to create this instance are saved as instance @@ -29,14 +27,13 @@ class BareMetalInfrastructureClientConfiguration(Configuration): # pylint: disa :type credential: ~azure.core.credentials.TokenCredential :param subscription_id: The ID of the target subscription. The value must be an UUID. Required. :type subscription_id: str - :keyword api_version: Api Version. Default value is "2023-08-04-preview". Note that overriding + :keyword api_version: Api Version. Default value is "2024-08-01-preview". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: - super(BareMetalInfrastructureClientConfiguration, self).__init__(**kwargs) - api_version: str = kwargs.pop("api_version", "2023-08-04-preview") + api_version: str = kwargs.pop("api_version", "2024-08-01-preview") if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -48,6 +45,7 @@ def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs self.api_version = api_version self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) kwargs.setdefault("sdk_moniker", "mgmt-baremetalinfrastructure/{}".format(VERSION)) + self.polling_interval = kwargs.get("polling_interval", 30) self._configure(**kwargs) def _configure(self, **kwargs: Any) -> None: @@ -56,9 +54,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/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_serialization.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_serialization.py index 4bae2292227b..f5187701d7be 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_serialization.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_serialization.py @@ -1,30 +1,12 @@ +# pylint: disable=line-too-long,useless-suppression,too-many-lines +# coding=utf-8 # -------------------------------------------------------------------------- -# # Copyright (c) Microsoft Corporation. All rights reserved. -# -# The MIT License (MIT) -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the ""Software""), to -# deal in the Software without restriction, including without limitation the -# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -# sell copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -# IN THE SOFTWARE. -# +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -# pylint: skip-file # pyright: reportUnnecessaryTypeIgnoreComment=false from base64 import b64decode, b64encode @@ -48,11 +30,8 @@ IO, Mapping, Callable, - TypeVar, MutableMapping, - Type, List, - Mapping, ) try: @@ -62,13 +41,13 @@ import xml.etree.ElementTree as ET import isodate # type: ignore +from typing_extensions import Self -from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback -from azure.core.serialization import NULL as AzureCoreNull +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] @@ -91,6 +70,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 @@ -112,7 +93,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: @@ -124,7 +105,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 @@ -143,7 +124,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 @@ -153,6 +136,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 @@ -170,13 +158,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: @@ -184,80 +165,31 @@ def deserialize_from_http_generics(cls, body_bytes: Optional[Union[AnyStr, IO]], except NameError: _long_type = int - -class UTC(datetime.tzinfo): - """Time Zone info for handling UTC""" - - def utcoffset(self, dt): - """UTF offset for UTC is 0.""" - return datetime.timedelta(0) - - def tzname(self, dt): - """Timestamp representation.""" - return "Z" - - def dst(self, dt): - """No daylight saving for UTC.""" - return datetime.timedelta(hours=1) - - -try: - from datetime import timezone as _FixedOffset # type: ignore -except ImportError: # Python 2.7 - - class _FixedOffset(datetime.tzinfo): # type: ignore - """Fixed offset in minutes east from UTC. - Copy/pasted from Python doc - :param datetime.timedelta offset: offset in timedelta format - """ - - def __init__(self, offset): - self.__offset = offset - - def utcoffset(self, dt): - return self.__offset - - def tzname(self, dt): - return str(self.__offset.total_seconds() / 3600) - - def __repr__(self): - return "".format(self.tzname(None)) - - def dst(self, dt): - return datetime.timedelta(0) - - def __getinitargs__(self): - return (self.__offset,) - - -try: - from datetime import timezone - - TZ_UTC = timezone.utc -except ImportError: - TZ_UTC = UTC() # type: ignore +TZ_UTC = datetime.timezone.utc _FLATTEN = re.compile(r"(? None: - self.additional_properties: Dict[str, Any] = {} - for k in kwargs: + 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): @@ -305,13 +244,23 @@ def __init__(self, **kwargs: Any) -> None: setattr(self, k, kwargs[k]) def __eq__(self, other: Any) -> bool: - """Compare objects by comparing all attributes.""" + """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: Any) -> bool: - """Compare objects by comparing all attributes.""" + """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) -> str: @@ -331,7 +280,11 @@ def is_xml_model(cls) -> bool: @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: @@ -340,7 +293,7 @@ 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: bool = False, **kwargs: Any) -> JSON: - """Return the JSON that would be sent to azure from this model. + """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)`. @@ -351,7 +304,9 @@ def serialize(self, keep_readonly: bool = False, **kwargs: Any) -> JSON: :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, @@ -385,12 +340,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): @@ -400,30 +358,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: Type[ModelType], data: Any, content_type: Optional[str] = None) -> ModelType: + def deserialize(cls, data: Any, content_type: Optional[str] = None) -> Self: """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 + :raises DeserializationError: if something went wrong + :rtype: Self """ 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: Type[ModelType], + cls, data: Any, key_extractors: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None, content_type: Optional[str] = None, - ) -> ModelType: + ) -> Self: """Parse a dict using given key extractor return a model. By default consider key @@ -431,9 +390,11 @@ def from_dict( 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 + :raises DeserializationError: if something went wrong + :rtype: Self """ deserializer = Deserializer(cls._infer_class_models()) deserializer.key_extractors = ( # type: ignore @@ -445,7 +406,7 @@ def from_dict( 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): @@ -453,21 +414,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: @@ -506,11 +471,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"} @@ -545,7 +512,7 @@ class Serializer(object): "multiple": lambda x, y: x % y != 0, } - def __init__(self, classes: Optional[Mapping[str, Type[ModelType]]] = None): + def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: self.serialize_type = { "iso-8601": Serializer.serialize_iso, "rfc-1123": Serializer.serialize_rfc, @@ -561,17 +528,20 @@ def __init__(self, classes: Optional[Mapping[str, Type[ModelType]]] = None): "[]": self.serialize_iter, "{}": self.serialize_dict, } - self.dependencies: Dict[str, Type[ModelType]] = 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. + :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) @@ -597,12 +567,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"] == "": @@ -638,7 +610,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 @@ -649,7 +622,7 @@ 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 @@ -668,18 +641,18 @@ def _serialize(self, target_obj, data_type=None, **kwargs): 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 + :raises SerializationError: if serialization fails. + :raises ValueError: if data is None + :returns: The serialized request body """ # Just in case this is a dict @@ -708,20 +681,22 @@ 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 - :raises: TypeError if serialization fails. - :raises: ValueError if data is None + :returns: The serialized URL path + :raises TypeError: if serialization fails. + :raises ValueError: if data is None """ try: output = self.serialize_data(data, data_type, **kwargs) @@ -730,30 +705,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. - :keyword bool skip_quote: Whether to skip quote the serialized result. - Defaults to False. - :rtype: str - :raises: TypeError if serialization fails. - :raises: ValueError if data is None + :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] do_quote = not kwargs.get("skip_quote", False) - return str(self.serialize_iter(data, internal_data_type, do_quote=do_quote, **kwargs)) + 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) @@ -763,19 +738,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 + :raises TypeError: if serialization fails. + :raises ValueError: if data is None + :returns: The serialized header """ try: if data_type in ["[str]"]: @@ -784,32 +760,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. + :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 AzureCoreNull: + 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 @@ -824,12 +799,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 @@ -845,23 +819,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 @@ -875,8 +852,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. @@ -886,15 +862,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'. - :keyword bool do_quote: Whether to quote the serialized result of each iterable element. Defaults to False. :rtype: list, str + :return: serialized iterable """ if isinstance(data, str): raise SerializationError("Refuse str type as a valid iter type.") @@ -949,9 +923,8 @@ 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 = {} @@ -975,7 +948,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 @@ -983,6 +956,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 @@ -993,7 +967,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) @@ -1007,7 +981,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: @@ -1038,56 +1012,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) @@ -1095,11 +1074,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) @@ -1109,30 +1089,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. + :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], @@ -1145,12 +1127,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. + :raises SerializationError: if format invalid. + :return: serialized iso """ if isinstance(attr, str): attr = isodate.parse_datetime(attr) @@ -1170,19 +1153,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 + :raises SerializationError: if format invalid + :return: serialied unix """ if isinstance(attr, int): return attr @@ -1190,11 +1174,11 @@ 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 @@ -1209,14 +1193,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 @@ -1230,7 +1215,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:]) @@ -1238,17 +1222,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) @@ -1285,7 +1281,7 @@ def _extract_name_from_internal_type(internal_type): 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 @@ -1337,22 +1333,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( + 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: @@ -1360,7 +1355,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. @@ -1369,9 +1364,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: Optional[Mapping[str, Type[ModelType]]] = None): + def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: self.deserialize_type = { "iso-8601": Deserializer.deserialize_iso, "rfc-1123": Deserializer.deserialize_rfc, @@ -1391,7 +1386,7 @@ def __init__(self, classes: Optional[Mapping[str, Type[ModelType]]] = None): "duration": (isodate.Duration, datetime.timedelta), "iso-8601": (datetime.datetime), } - self.dependencies: Dict[str, Type[ModelType]] = 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 @@ -1407,27 +1402,29 @@ def __call__(self, target_obj, response_data, content_type=None): :param str target_obj: Target data type to deserialize to. :param requests.Response response_data: REST response object. :param str content_type: Swagger "produces" if available. - :raises: DeserializationError if deserialization fails. + :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 :param str target_obj: Target data type to deserialize to. :param object data: Object to deserialize. - :raises: DeserializationError if deserialization fails. + :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) @@ -1444,15 +1441,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"... @@ -1481,10 +1478,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: @@ -1511,18 +1507,20 @@ def _classify_target(self, target, data): :param str target: The target object type to deserialize to. :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__ # type: ignore @@ -1537,10 +1535,12 @@ def failsafe_deserialize(self, target_obj, data, content_type=None): :param str target_obj: The target object type to deserialize to. :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 ) @@ -1558,10 +1558,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", {}) @@ -1578,31 +1580,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(): @@ -1611,15 +1624,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. + :raises DeserializationError: if deserialization fails. :return: Deserialized object. + :rtype: object """ if data is None: return data @@ -1633,7 +1647,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) @@ -1652,15 +1670,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: @@ -1677,6 +1695,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): @@ -1687,20 +1706,21 @@ 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. + :raises TypeError: if non-builtin datatype encountered. """ if attr is None: return None if isinstance(attr, ET.Element): # Do no recurse on XML, just return the tree as-is return attr - if isinstance(attr, basestring): + if isinstance(attr, str): return self.deserialize_basic(attr, "str") obj_type = type(attr) if obj_type in self.basic_types: @@ -1726,11 +1746,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 @@ -1738,8 +1757,9 @@ 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. + :raises TypeError: if string format is not valid. """ # If we're here, data is supposed to be a basic type. # If it's still an XML node, take the text @@ -1749,24 +1769,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): @@ -1774,6 +1793,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, @@ -1787,8 +1807,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): @@ -1800,6 +1819,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: @@ -1808,12 +1828,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: @@ -1829,8 +1848,9 @@ 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. + :raises TypeError: if string format invalid. """ if isinstance(attr, ET.Element): attr = attr.text @@ -1841,8 +1861,9 @@ 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. + :raises TypeError: if string format invalid. """ if isinstance(attr, ET.Element): attr = attr.text @@ -1856,24 +1877,26 @@ def deserialize_decimal(attr): """Deserialize string into Decimal object. :param str attr: response string to be deserialized. - :rtype: Decimal - :raises: DeserializationError if string format invalid. + :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. + :raises ValueError: if string format invalid. """ if isinstance(attr, ET.Element): attr = attr.text @@ -1884,8 +1907,9 @@ 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. + :raises DeserializationError: if string format invalid. """ if isinstance(attr, ET.Element): attr = attr.text @@ -1893,32 +1917,33 @@ 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. + :raises DeserializationError: if string format invalid. """ if isinstance(attr, ET.Element): attr = attr.text if re.search(r"[^\W\d_]", attr, re.I + re.U): # 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. + :raises DeserializationError: if string format invalid. """ if isinstance(attr, ET.Element): attr = attr.text @@ -1931,31 +1956,32 @@ 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. + :raises DeserializationError: if string format invalid. """ if isinstance(attr, ET.Element): attr = attr.text try: parsed_date = email.utils.parsedate_tz(attr) # type: ignore date_obj = datetime.datetime( - *parsed_date[:6], tzinfo=_FixedOffset(datetime.timedelta(minutes=(parsed_date[9] or 0) / 60)) + *parsed_date[:6], tzinfo=datetime.timezone(datetime.timedelta(minutes=(parsed_date[9] or 0) / 60)) ) if not date_obj.tzinfo: date_obj = date_obj.astimezone(tz=TZ_UTC) except ValueError as err: msg = "Cannot deserialize to rfc datetime object." - raise_with_traceback(DeserializationError, msg, err) - else: - return date_obj + 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. + :raises DeserializationError: if string format invalid. """ if isinstance(attr, ET.Element): attr = attr.text @@ -1982,9 +2008,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): @@ -1992,15 +2017,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 + :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/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_vendor.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_vendor.py deleted file mode 100644 index 0dafe0e287ff..000000000000 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_vendor.py +++ /dev/null @@ -1,16 +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 diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_version.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_version.py index f1fb63697cf5..73aef742777f 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_version.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "1.1.0b2" +VERSION = "1.1.0b3" diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/__init__.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/__init__.py index d297a609c1bd..7f8e4d54f94f 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/__init__.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/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 ._bare_metal_infrastructure_client import BareMetalInfrastructureClient +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._bare_metal_infrastructure_client import BareMetalInfrastructureClient # 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__ = [ "BareMetalInfrastructureClient", ] -__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/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/_bare_metal_infrastructure_client.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/_bare_metal_infrastructure_client.py index 2aa665956533..a081b9281823 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/_bare_metal_infrastructure_client.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/_bare_metal_infrastructure_client.py @@ -7,10 +7,15 @@ # -------------------------------------------------------------------------- from copy import deepcopy -from typing import Any, Awaitable, TYPE_CHECKING +from typing import Any, Awaitable, Optional, TYPE_CHECKING, cast +from typing_extensions import Self +from azure.core.pipeline import policies from azure.core.rest import AsyncHttpResponse, HttpRequest +from azure.core.settings import settings from azure.mgmt.core import AsyncARMPipelineClient +from azure.mgmt.core.policies import AsyncARMAutoResourceProviderRegistrationPolicy +from azure.mgmt.core.tools import get_arm_endpoints from .. import models as _models from .._serialization import Deserializer, Serializer @@ -18,11 +23,10 @@ from .operations import AzureBareMetalInstancesOperations, AzureBareMetalStorageInstancesOperations, Operations if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials_async import AsyncTokenCredential -class BareMetalInfrastructureClient: # pylint: disable=client-accepts-api-version-keyword +class BareMetalInfrastructureClient: """The Bare Metal Infrastructure Management client. :ivar azure_bare_metal_instances: AzureBareMetalInstancesOperations operations @@ -37,9 +41,9 @@ class BareMetalInfrastructureClient: # pylint: disable=client-accepts-api-versi :type credential: ~azure.core.credentials_async.AsyncTokenCredential :param subscription_id: The ID of the target subscription. The value must be an UUID. Required. :type subscription_id: str - :param base_url: Service URL. Default value is "https://management.azure.com". + :param base_url: Service URL. Default value is None. :type base_url: str - :keyword api_version: Api Version. Default value is "2023-08-04-preview". Note that overriding + :keyword api_version: Api Version. Default value is "2024-08-01-preview". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str :keyword int polling_interval: Default waiting time between two polls for LRO operations if no @@ -47,16 +51,38 @@ class BareMetalInfrastructureClient: # pylint: disable=client-accepts-api-versi """ def __init__( - self, - credential: "AsyncTokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any + self, credential: "AsyncTokenCredential", subscription_id: str, base_url: Optional[str] = None, **kwargs: Any ) -> None: + _cloud = kwargs.pop("cloud_setting", None) or settings.current.azure_cloud # type: ignore + _endpoints = get_arm_endpoints(_cloud) + if not base_url: + base_url = _endpoints["resource_manager"] + credential_scopes = kwargs.pop("credential_scopes", _endpoints["credential_scopes"]) self._config = BareMetalInfrastructureClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs + credential=credential, subscription_id=subscription_id, credential_scopes=credential_scopes, **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=cast(str, base_url), policies=_policies, **kwargs ) - self._client: AsyncARMPipelineClient = AsyncARMPipelineClient(base_url=base_url, config=self._config, **kwargs) client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) @@ -70,7 +96,9 @@ def __init__( 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 @@ -90,12 +118,12 @@ 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) -> "BareMetalInfrastructureClient": + async def __aenter__(self) -> Self: await self._client.__aenter__() return self diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/_configuration.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/_configuration.py index e9d2994ac3b2..91ccbc77e5c8 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/_configuration.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/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 BareMetalInfrastructureClientConfiguration(Configuration): # pylint: disable=too-many-instance-attributes +class BareMetalInfrastructureClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long """Configuration for BareMetalInfrastructureClient. Note that all parameters used to create this instance are saved as instance @@ -29,14 +27,13 @@ class BareMetalInfrastructureClientConfiguration(Configuration): # pylint: disa :type credential: ~azure.core.credentials_async.AsyncTokenCredential :param subscription_id: The ID of the target subscription. The value must be an UUID. Required. :type subscription_id: str - :keyword api_version: Api Version. Default value is "2023-08-04-preview". Note that overriding + :keyword api_version: Api Version. Default value is "2024-08-01-preview". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: - super(BareMetalInfrastructureClientConfiguration, self).__init__(**kwargs) - api_version: str = kwargs.pop("api_version", "2023-08-04-preview") + api_version: str = kwargs.pop("api_version", "2024-08-01-preview") if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -48,6 +45,7 @@ def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **k self.api_version = api_version self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) kwargs.setdefault("sdk_moniker", "mgmt-baremetalinfrastructure/{}".format(VERSION)) + self.polling_interval = kwargs.get("polling_interval", 30) self._configure(**kwargs) def _configure(self, **kwargs: Any) -> None: @@ -56,9 +54,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/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/__init__.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/__init__.py index 3e12b5ce7466..74cab9f97daf 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/__init__.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/__init__.py @@ -5,13 +5,19 @@ # 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 ._azure_bare_metal_instances_operations import AzureBareMetalInstancesOperations -from ._operations import Operations -from ._azure_bare_metal_storage_instances_operations import AzureBareMetalStorageInstancesOperations +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._azure_bare_metal_instances_operations import AzureBareMetalInstancesOperations # type: ignore +from ._operations import Operations # type: ignore +from ._azure_bare_metal_storage_instances_operations import AzureBareMetalStorageInstancesOperations # 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__ = [ @@ -19,5 +25,5 @@ "Operations", "AzureBareMetalStorageInstancesOperations", ] -__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/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/_azure_bare_metal_instances_operations.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/_azure_bare_metal_instances_operations.py index d0a52aee0314..e3bf821acfb6 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/_azure_bare_metal_instances_operations.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/_azure_bare_metal_instances_operations.py @@ -6,10 +6,12 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +from collections.abc import MutableMapping from io import IOBase -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload import urllib.parse +from azure.core import AsyncPipelineClient from azure.core.async_paging import AsyncItemPaged, AsyncList from azure.core.exceptions import ( ClientAuthenticationError, @@ -17,12 +19,13 @@ 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 import distributed_trace from azure.core.tracing.decorator_async import distributed_trace_async from azure.core.utils import case_insensitive_dict @@ -30,8 +33,10 @@ from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling from ... import models as _models -from ..._vendor import _convert_request +from ..._serialization import Deserializer, Serializer from ...operations._azure_bare_metal_instances_operations import ( + build_create_request, + build_delete_request, build_get_request, build_list_by_resource_group_request, build_list_by_subscription_request, @@ -40,6 +45,7 @@ build_start_request, build_update_request, ) +from .._configuration import BareMetalInfrastructureClientConfiguration T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -59,15 +65,17 @@ class AzureBareMetalInstancesOperations: 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") + self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: BareMetalInfrastructureClientConfiguration = ( + input_args.pop(0) if input_args else kwargs.pop("config") + ) + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") async def _start_initial( self, resource_group_name: str, azure_bare_metal_instance_name: str, **kwargs: Any - ) -> Optional[_models.OperationStatus]: - error_map = { + ) -> AsyncIterator[bytes]: + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -79,48 +87,45 @@ async def _start_initial( _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) - cls: ClsType[Optional[_models.OperationStatus]] = kwargs.pop("cls", None) + cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - request = build_start_request( + _request = build_start_request( resource_group_name=resource_group_name, azure_bare_metal_instance_name=azure_bare_metal_instance_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._start_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) - _stream = False + _decompress = kwargs.pop("decompress", True) + _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response if response.status_code not in [200, 202]: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = None response_headers = {} - if response.status_code == 200: - deserialized = self._deserialize("OperationStatus", pipeline_response) - if response.status_code == 202: response_headers["location"] = self._deserialize("str", response.headers.get("location")) - if cls: - return cls(pipeline_response, deserialized, response_headers) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) - return deserialized + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore - _start_initial.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}/start" - } + return deserialized # type: ignore @distributed_trace_async async def begin_start( @@ -136,14 +141,6 @@ async def begin_start( :param azure_bare_metal_instance_name: Name of the Azure Bare Metal Instance, also known as the ResourceName. Required. :type azure_bare_metal_instance_name: 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 OperationStatus or the result of cls(response) :rtype: @@ -168,12 +165,13 @@ async def begin_start( 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("OperationStatus", pipeline_response) + deserialized = self._deserialize("OperationStatus", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore return deserialized if polling is True: @@ -185,26 +183,24 @@ def get_long_running_output(pipeline_response): else: polling_method = polling if cont_token: - return AsyncLROPoller.from_continuation_token( + return AsyncLROPoller[_models.OperationStatus].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_start.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}/start" - } + return AsyncLROPoller[_models.OperationStatus]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) async def _restart_initial( self, resource_group_name: str, azure_bare_metal_instance_name: str, - force_parameter: Optional[Union[_models.ForceState, IO]] = None, + force_parameter: Optional[Union[_models.ForceState, IO[bytes]]] = None, **kwargs: Any - ) -> Optional[_models.OperationStatus]: - error_map = { + ) -> AsyncIterator[bytes]: + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -217,7 +213,7 @@ async def _restart_initial( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Optional[_models.OperationStatus]] = kwargs.pop("cls", None) + cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -230,7 +226,7 @@ async def _restart_initial( else: _json = None - request = build_restart_request( + _request = build_restart_request( resource_group_name=resource_group_name, azure_bare_metal_instance_name=azure_bare_metal_instance_name, subscription_id=self._config.subscription_id, @@ -238,41 +234,38 @@ async def _restart_initial( content_type=content_type, json=_json, content=_content, - template_url=self._restart_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) - _stream = False + _decompress = kwargs.pop("decompress", True) + _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response if response.status_code not in [200, 202]: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = None response_headers = {} - if response.status_code == 200: - deserialized = self._deserialize("OperationStatus", pipeline_response) - if response.status_code == 202: response_headers["location"] = self._deserialize("str", response.headers.get("location")) - if cls: - return cls(pipeline_response, deserialized, response_headers) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) - return deserialized + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore - _restart_initial.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}/restart" - } + return deserialized # type: ignore @overload async def begin_restart( @@ -301,14 +294,6 @@ async def begin_restart( :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 OperationStatus or the result of cls(response) :rtype: @@ -321,7 +306,7 @@ async def begin_restart( self, resource_group_name: str, azure_bare_metal_instance_name: str, - force_parameter: Optional[IO] = None, + force_parameter: Optional[IO[bytes]] = None, *, content_type: str = "application/json", **kwargs: Any @@ -339,18 +324,10 @@ async def begin_restart( :param force_parameter: When set to 'active', this parameter empowers the server with the ability to forcefully terminate and halt any existing processes that may be running on the server. Default value is None. - :type force_parameter: IO + :type force_parameter: 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 OperationStatus or the result of cls(response) :rtype: @@ -363,7 +340,7 @@ async def begin_restart( self, resource_group_name: str, azure_bare_metal_instance_name: str, - force_parameter: Optional[Union[_models.ForceState, IO]] = None, + force_parameter: Optional[Union[_models.ForceState, IO[bytes]]] = None, **kwargs: Any ) -> AsyncLROPoller[_models.OperationStatus]: """Restart a Bare Metal Instance. @@ -378,19 +355,8 @@ async def begin_restart( :type azure_bare_metal_instance_name: str :param force_parameter: When set to 'active', this parameter empowers the server with the ability to forcefully terminate and halt any existing processes that may be running on the - server. Is either a ForceState type or a IO type. Default value is None. - :type force_parameter: ~azure.mgmt.baremetalinfrastructure.models.ForceState 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. + server. Is either a ForceState type or a IO[bytes] type. Default value is None. + :type force_parameter: ~azure.mgmt.baremetalinfrastructure.models.ForceState or IO[bytes] :return: An instance of AsyncLROPoller that returns either OperationStatus or the result of cls(response) :rtype: @@ -418,12 +384,13 @@ async def begin_restart( 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("OperationStatus", pipeline_response) + deserialized = self._deserialize("OperationStatus", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore return deserialized if polling is True: @@ -435,22 +402,20 @@ def get_long_running_output(pipeline_response): else: polling_method = polling if cont_token: - return AsyncLROPoller.from_continuation_token( + return AsyncLROPoller[_models.OperationStatus].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_restart.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}/restart" - } + return AsyncLROPoller[_models.OperationStatus]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) async def _shutdown_initial( self, resource_group_name: str, azure_bare_metal_instance_name: str, **kwargs: Any - ) -> Optional[_models.OperationStatus]: - error_map = { + ) -> AsyncIterator[bytes]: + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -462,48 +427,45 @@ async def _shutdown_initial( _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) - cls: ClsType[Optional[_models.OperationStatus]] = kwargs.pop("cls", None) + cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - request = build_shutdown_request( + _request = build_shutdown_request( resource_group_name=resource_group_name, azure_bare_metal_instance_name=azure_bare_metal_instance_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._shutdown_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) - _stream = False + _decompress = kwargs.pop("decompress", True) + _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response if response.status_code not in [200, 202]: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = None response_headers = {} - if response.status_code == 200: - deserialized = self._deserialize("OperationStatus", pipeline_response) - if response.status_code == 202: response_headers["location"] = self._deserialize("str", response.headers.get("location")) - if cls: - return cls(pipeline_response, deserialized, response_headers) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) - return deserialized + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore - _shutdown_initial.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}/shutdown" - } + return deserialized # type: ignore @distributed_trace_async async def begin_shutdown( @@ -519,14 +481,6 @@ async def begin_shutdown( :param azure_bare_metal_instance_name: Name of the Azure Bare Metal Instance, also known as the ResourceName. Required. :type azure_bare_metal_instance_name: 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 OperationStatus or the result of cls(response) :rtype: @@ -551,12 +505,13 @@ async def begin_shutdown( 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("OperationStatus", pipeline_response) + deserialized = self._deserialize("OperationStatus", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore return deserialized if polling is True: @@ -568,17 +523,15 @@ def get_long_running_output(pipeline_response): else: polling_method = polling if cont_token: - return AsyncLROPoller.from_continuation_token( + return AsyncLROPoller[_models.OperationStatus].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_shutdown.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}/shutdown" - } + return AsyncLROPoller[_models.OperationStatus]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) @distributed_trace def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.AzureBareMetalInstance"]: @@ -587,7 +540,6 @@ def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.AzureBar Returns a list of Azure Bare Metal Instances in the specified subscription. The operations returns various properties of each Azure Bare Metal Instance. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either AzureBareMetalInstance or the result of cls(response) :rtype: @@ -600,7 +552,7 @@ def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.AzureBar api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[_models.AzureBareMetalInstancesListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -611,15 +563,13 @@ def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.AzureBar def prepare_request(next_link=None): if not next_link: - request = build_list_by_subscription_request( + _request = build_list_by_subscription_request( subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -631,13 +581,12 @@ def prepare_request(next_link=None): } ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( + _request = HttpRequest( "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request async def extract_data(pipeline_response): deserialized = self._deserialize("AzureBareMetalInstancesListResult", pipeline_response) @@ -647,11 +596,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=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -664,10 +613,6 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_subscription.metadata = { - "url": "/subscriptions/{subscriptionId}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances" - } - @distributed_trace def list_by_resource_group( self, resource_group_name: str, **kwargs: Any @@ -680,7 +625,6 @@ def list_by_resource_group( :param resource_group_name: The name of the resource group. The name is case insensitive. Required. :type resource_group_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either AzureBareMetalInstance or the result of cls(response) :rtype: @@ -693,7 +637,7 @@ def list_by_resource_group( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[_models.AzureBareMetalInstancesListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -704,16 +648,14 @@ def list_by_resource_group( def prepare_request(next_link=None): if not next_link: - request = build_list_by_resource_group_request( + _request = build_list_by_resource_group_request( resource_group_name=resource_group_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -725,13 +667,12 @@ def prepare_request(next_link=None): } ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( + _request = HttpRequest( "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request async def extract_data(pipeline_response): deserialized = self._deserialize("AzureBareMetalInstancesListResult", pipeline_response) @@ -741,11 +682,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=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -758,10 +699,6 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_resource_group.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances" - } - @distributed_trace_async async def get( self, resource_group_name: str, azure_bare_metal_instance_name: str, **kwargs: Any @@ -777,12 +714,11 @@ async def get( :param azure_bare_metal_instance_name: Name of the Azure Bare Metal Instance, also known as the ResourceName. Required. :type azure_bare_metal_instance_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: AzureBareMetalInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -796,21 +732,19 @@ async def get( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[_models.AzureBareMetalInstance] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, azure_bare_metal_instance_name=azure_bare_metal_instance_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -820,16 +754,151 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("AzureBareMetalInstance", pipeline_response) + deserialized = self._deserialize("AzureBareMetalInstance", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @overload + async def create( + self, + resource_group_name: str, + azure_bare_metal_instance_name: str, + request_body_parameters: _models.AzureBareMetalInstance, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AzureBareMetalInstance: + """Creates an Azure Bare Metal Instance for the specified subscription, resource group, and + instance name. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param azure_bare_metal_instance_name: Name of the Azure Bare Metal Instance, also known as the + ResourceName. Required. + :type azure_bare_metal_instance_name: str + :param request_body_parameters: Resource create parameters. Required. + :type request_body_parameters: + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: AzureBareMetalInstance or the result of cls(response) + :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create( + self, + resource_group_name: str, + azure_bare_metal_instance_name: str, + request_body_parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AzureBareMetalInstance: + """Creates an Azure Bare Metal Instance for the specified subscription, resource group, and + instance name. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param azure_bare_metal_instance_name: Name of the Azure Bare Metal Instance, also known as the + ResourceName. Required. + :type azure_bare_metal_instance_name: str + :param request_body_parameters: Resource create parameters. Required. + :type request_body_parameters: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: AzureBareMetalInstance or the result of cls(response) + :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create( + self, + resource_group_name: str, + azure_bare_metal_instance_name: str, + request_body_parameters: Union[_models.AzureBareMetalInstance, IO[bytes]], + **kwargs: Any + ) -> _models.AzureBareMetalInstance: + """Creates an Azure Bare Metal Instance for the specified subscription, resource group, and + instance name. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param azure_bare_metal_instance_name: Name of the Azure Bare Metal Instance, also known as the + ResourceName. Required. + :type azure_bare_metal_instance_name: str + :param request_body_parameters: Resource create parameters. Is either a AzureBareMetalInstance + type or a IO[bytes] type. Required. + :type request_body_parameters: + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance or IO[bytes] + :return: AzureBareMetalInstance or the result of cls(response) + :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - return deserialized + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.AzureBareMetalInstance] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(request_body_parameters, (IOBase, bytes)): + _content = request_body_parameters + else: + _json = self._serialize.body(request_body_parameters, "AzureBareMetalInstance") + + _request = build_create_request( + resource_group_name=resource_group_name, + azure_bare_metal_instance_name=azure_bare_metal_instance_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("AzureBareMetalInstance", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore - get.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}" - } + return deserialized # type: ignore @overload async def update( @@ -857,7 +926,6 @@ async def update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: AzureBareMetalInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance :raises ~azure.core.exceptions.HttpResponseError: @@ -868,7 +936,7 @@ async def update( self, resource_group_name: str, azure_bare_metal_instance_name: str, - tags_parameter: IO, + tags_parameter: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -885,11 +953,10 @@ async def update( ResourceName. Required. :type azure_bare_metal_instance_name: str :param tags_parameter: Request body that only contains the new Tags field. Required. - :type tags_parameter: IO + :type tags_parameter: 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: AzureBareMetalInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance :raises ~azure.core.exceptions.HttpResponseError: @@ -900,7 +967,7 @@ async def update( self, resource_group_name: str, azure_bare_metal_instance_name: str, - tags_parameter: Union[_models.Tags, IO], + tags_parameter: Union[_models.Tags, IO[bytes]], **kwargs: Any ) -> _models.AzureBareMetalInstance: """Patches the Tags field of a Azure Bare Metal Instance. @@ -915,17 +982,13 @@ async def update( ResourceName. Required. :type azure_bare_metal_instance_name: str :param tags_parameter: Request body that only contains the new Tags field. Is either a Tags - type or a IO type. Required. - :type tags_parameter: ~azure.mgmt.baremetalinfrastructure.models.Tags 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 + type or a IO[bytes] type. Required. + :type tags_parameter: ~azure.mgmt.baremetalinfrastructure.models.Tags or IO[bytes] :return: AzureBareMetalInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -948,7 +1011,7 @@ async def update( else: _json = self._serialize.body(tags_parameter, "Tags") - request = build_update_request( + _request = build_update_request( resource_group_name=resource_group_name, azure_bare_metal_instance_name=azure_bare_metal_instance_name, subscription_id=self._config.subscription_id, @@ -956,16 +1019,14 @@ async def update( content_type=content_type, json=_json, content=_content, - template_url=self.update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -975,13 +1036,63 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("AzureBareMetalInstance", pipeline_response) + deserialized = self._deserialize("AzureBareMetalInstance", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def delete(self, resource_group_name: str, azure_bare_metal_instance_name: str, **kwargs: Any) -> None: + """Deletes an Azure Bare Metal Instance for the specified subscription, resource group, and + instance name. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param azure_bare_metal_instance_name: Name of the Azure Bare Metal Instance, also known as the + ResourceName. Required. + :type azure_bare_metal_instance_name: str + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - return deserialized + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[None] = kwargs.pop("cls", None) - update.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}" - } + _request = build_delete_request( + resource_group_name=resource_group_name, + azure_bare_metal_instance_name=azure_bare_metal_instance_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 204]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if cls: + return cls(pipeline_response, None, {}) # type: ignore diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/_azure_bare_metal_storage_instances_operations.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/_azure_bare_metal_storage_instances_operations.py index 4f769834ae2e..730e0c294691 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/_azure_bare_metal_storage_instances_operations.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/_azure_bare_metal_storage_instances_operations.py @@ -1,4 +1,4 @@ -# pylint: disable=too-many-lines +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +6,12 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +from collections.abc import MutableMapping from io import IOBase from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload import urllib.parse +from azure.core import AsyncPipelineClient from azure.core.async_paging import AsyncItemPaged, AsyncList from azure.core.exceptions import ( ClientAuthenticationError, @@ -20,15 +22,14 @@ 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 ..._serialization import Deserializer, Serializer from ...operations._azure_bare_metal_storage_instances_operations import ( build_create_request, build_delete_request, @@ -37,6 +38,7 @@ build_list_by_subscription_request, build_update_request, ) +from .._configuration import BareMetalInfrastructureClientConfiguration T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -56,10 +58,12 @@ class AzureBareMetalStorageInstancesOperations: 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") + self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: BareMetalInfrastructureClientConfiguration = ( + input_args.pop(0) if input_args else kwargs.pop("config") + ) + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.AzureBareMetalStorageInstance"]: @@ -68,7 +72,6 @@ def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.AzureBar Gets a list of AzureBareMetalStorage instances in the specified subscription. The operations returns various properties of each Azure Bare Metal Instance. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either AzureBareMetalStorageInstance or the result of cls(response) :rtype: @@ -81,7 +84,7 @@ def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.AzureBar api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[_models.AzureBareMetalStorageInstancesListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -92,15 +95,13 @@ def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.AzureBar def prepare_request(next_link=None): if not next_link: - request = build_list_by_subscription_request( + _request = build_list_by_subscription_request( subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -112,13 +113,12 @@ def prepare_request(next_link=None): } ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( + _request = HttpRequest( "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request async def extract_data(pipeline_response): deserialized = self._deserialize("AzureBareMetalStorageInstancesListResult", pipeline_response) @@ -128,11 +128,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=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -145,10 +145,6 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_subscription.metadata = { - "url": "/subscriptions/{subscriptionId}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances" - } - @distributed_trace def list_by_resource_group( self, resource_group_name: str, **kwargs: Any @@ -162,7 +158,6 @@ def list_by_resource_group( :param resource_group_name: The name of the resource group. The name is case insensitive. Required. :type resource_group_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either AzureBareMetalStorageInstance or the result of cls(response) :rtype: @@ -175,7 +170,7 @@ def list_by_resource_group( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[_models.AzureBareMetalStorageInstancesListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -186,16 +181,14 @@ def list_by_resource_group( def prepare_request(next_link=None): if not next_link: - request = build_list_by_resource_group_request( + _request = build_list_by_resource_group_request( resource_group_name=resource_group_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -207,13 +200,12 @@ def prepare_request(next_link=None): } ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( + _request = HttpRequest( "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request async def extract_data(pipeline_response): deserialized = self._deserialize("AzureBareMetalStorageInstancesListResult", pipeline_response) @@ -223,11 +215,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=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -240,10 +232,6 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_resource_group.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances" - } - @distributed_trace_async async def get( self, resource_group_name: str, azure_bare_metal_storage_instance_name: str, **kwargs: Any @@ -259,12 +247,11 @@ async def get( :param azure_bare_metal_storage_instance_name: Name of the Azure Bare Metal Storage Instance, also known as the ResourceName. Required. :type azure_bare_metal_storage_instance_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: AzureBareMetalStorageInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -278,21 +265,19 @@ async def get( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[_models.AzureBareMetalStorageInstance] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, azure_bare_metal_storage_instance_name=azure_bare_metal_storage_instance_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -302,16 +287,12 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("AzureBareMetalStorageInstance", pipeline_response) + deserialized = self._deserialize("AzureBareMetalStorageInstance", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - get.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances/{azureBareMetalStorageInstanceName}" - } + return deserialized # type: ignore @overload async def create( @@ -325,7 +306,8 @@ async def create( ) -> _models.AzureBareMetalStorageInstance: """Create an azure bare metal storage resource. - Create an azure bare metal storage resource. + Creates an Azure Bare Metal Storage Instance for the specified subscription, resource group, + and instance name. :param resource_group_name: The name of the resource group. The name is case insensitive. Required. @@ -339,7 +321,6 @@ async def 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 :return: AzureBareMetalStorageInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance :raises ~azure.core.exceptions.HttpResponseError: @@ -350,14 +331,15 @@ async def create( self, resource_group_name: str, azure_bare_metal_storage_instance_name: str, - request_body_parameters: IO, + request_body_parameters: IO[bytes], *, content_type: str = "application/json", **kwargs: Any ) -> _models.AzureBareMetalStorageInstance: """Create an azure bare metal storage resource. - Create an azure bare metal storage resource. + Creates an Azure Bare Metal Storage Instance for the specified subscription, resource group, + and instance name. :param resource_group_name: The name of the resource group. The name is case insensitive. Required. @@ -366,11 +348,10 @@ async def create( also known as the ResourceName. Required. :type azure_bare_metal_storage_instance_name: str :param request_body_parameters: request body for put call. Required. - :type request_body_parameters: IO + :type request_body_parameters: IO[bytes] :keyword content_type: Body Parameter content-type. Content type parameter for binary body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: AzureBareMetalStorageInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance :raises ~azure.core.exceptions.HttpResponseError: @@ -381,12 +362,13 @@ async def create( self, resource_group_name: str, azure_bare_metal_storage_instance_name: str, - request_body_parameters: Union[_models.AzureBareMetalStorageInstance, IO], + request_body_parameters: Union[_models.AzureBareMetalStorageInstance, IO[bytes]], **kwargs: Any ) -> _models.AzureBareMetalStorageInstance: """Create an azure bare metal storage resource. - Create an azure bare metal storage resource. + Creates an Azure Bare Metal Storage Instance for the specified subscription, resource group, + and instance name. :param resource_group_name: The name of the resource group. The name is case insensitive. Required. @@ -395,18 +377,14 @@ async def create( also known as the ResourceName. Required. :type azure_bare_metal_storage_instance_name: str :param request_body_parameters: request body for put call. Is either a - AzureBareMetalStorageInstance type or a IO type. Required. + AzureBareMetalStorageInstance type or a IO[bytes] type. Required. :type request_body_parameters: - ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance 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 + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance or IO[bytes] :return: AzureBareMetalStorageInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -429,7 +407,7 @@ async def create( else: _json = self._serialize.body(request_body_parameters, "AzureBareMetalStorageInstance") - request = build_create_request( + _request = build_create_request( resource_group_name=resource_group_name, azure_bare_metal_storage_instance_name=azure_bare_metal_storage_instance_name, subscription_id=self._config.subscription_id, @@ -437,16 +415,14 @@ async def create( content_type=content_type, json=_json, content=_content, - template_url=self.create.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _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 + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -456,34 +432,26 @@ async def create( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("AzureBareMetalStorageInstance", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("AzureBareMetalStorageInstance", pipeline_response) + deserialized = self._deserialize("AzureBareMetalStorageInstance", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore return deserialized # type: ignore - create.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances/{azureBareMetalStorageInstanceName}" - } - @overload async def update( self, resource_group_name: str, azure_bare_metal_storage_instance_name: str, - tags_parameter: _models.Tags, + azure_bare_metal_storage_instance_body_parameter: _models.AzureBareMetalStorageInstanceBody, *, content_type: str = "application/json", **kwargs: Any ) -> _models.AzureBareMetalStorageInstance: - """Patches the Tags field of a Azure Bare Metal Storage instance. + """Patches the Tags field of a Azure BareMetalStorage instance. - Patches the Tags field of a Azure Bare Metal Storage instance for the specified subscription, + Patches the Tags field of a Azure BareMetalStorage instance for the specified subscription, resource group, and instance name. :param resource_group_name: The name of the resource group. The name is case insensitive. @@ -492,12 +460,13 @@ async def update( :param azure_bare_metal_storage_instance_name: Name of the Azure Bare Metal Storage Instance, also known as the ResourceName. Required. :type azure_bare_metal_storage_instance_name: str - :param tags_parameter: Request body that only contains the new Tags field. Required. - :type tags_parameter: ~azure.mgmt.baremetalinfrastructure.models.Tags + :param azure_bare_metal_storage_instance_body_parameter: Request body that only contains the + Tags and Identity Field. Required. + :type azure_bare_metal_storage_instance_body_parameter: + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstanceBody :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: AzureBareMetalStorageInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance :raises ~azure.core.exceptions.HttpResponseError: @@ -508,14 +477,14 @@ async def update( self, resource_group_name: str, azure_bare_metal_storage_instance_name: str, - tags_parameter: IO, + azure_bare_metal_storage_instance_body_parameter: IO[bytes], *, content_type: str = "application/json", **kwargs: Any ) -> _models.AzureBareMetalStorageInstance: - """Patches the Tags field of a Azure Bare Metal Storage instance. + """Patches the Tags field of a Azure BareMetalStorage instance. - Patches the Tags field of a Azure Bare Metal Storage instance for the specified subscription, + Patches the Tags field of a Azure BareMetalStorage instance for the specified subscription, resource group, and instance name. :param resource_group_name: The name of the resource group. The name is case insensitive. @@ -524,12 +493,12 @@ async def update( :param azure_bare_metal_storage_instance_name: Name of the Azure Bare Metal Storage Instance, also known as the ResourceName. Required. :type azure_bare_metal_storage_instance_name: str - :param tags_parameter: Request body that only contains the new Tags field. Required. - :type tags_parameter: IO + :param azure_bare_metal_storage_instance_body_parameter: Request body that only contains the + Tags and Identity Field. Required. + :type azure_bare_metal_storage_instance_body_parameter: 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: AzureBareMetalStorageInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance :raises ~azure.core.exceptions.HttpResponseError: @@ -540,12 +509,12 @@ async def update( self, resource_group_name: str, azure_bare_metal_storage_instance_name: str, - tags_parameter: Union[_models.Tags, IO], + azure_bare_metal_storage_instance_body_parameter: Union[_models.AzureBareMetalStorageInstanceBody, IO[bytes]], **kwargs: Any ) -> _models.AzureBareMetalStorageInstance: - """Patches the Tags field of a Azure Bare Metal Storage instance. + """Patches the Tags field of a Azure BareMetalStorage instance. - Patches the Tags field of a Azure Bare Metal Storage instance for the specified subscription, + Patches the Tags field of a Azure BareMetalStorage instance for the specified subscription, resource group, and instance name. :param resource_group_name: The name of the resource group. The name is case insensitive. @@ -554,18 +523,16 @@ async def update( :param azure_bare_metal_storage_instance_name: Name of the Azure Bare Metal Storage Instance, also known as the ResourceName. Required. :type azure_bare_metal_storage_instance_name: str - :param tags_parameter: Request body that only contains the new Tags field. Is either a Tags - type or a IO type. Required. - :type tags_parameter: ~azure.mgmt.baremetalinfrastructure.models.Tags 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 azure_bare_metal_storage_instance_body_parameter: Request body that only contains the + Tags and Identity Field. Is either a AzureBareMetalStorageInstanceBody type or a IO[bytes] + type. Required. + :type azure_bare_metal_storage_instance_body_parameter: + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstanceBody or IO[bytes] :return: AzureBareMetalStorageInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -583,12 +550,14 @@ async def update( content_type = content_type or "application/json" _json = None _content = None - if isinstance(tags_parameter, (IOBase, bytes)): - _content = tags_parameter + if isinstance(azure_bare_metal_storage_instance_body_parameter, (IOBase, bytes)): + _content = azure_bare_metal_storage_instance_body_parameter else: - _json = self._serialize.body(tags_parameter, "Tags") + _json = self._serialize.body( + azure_bare_metal_storage_instance_body_parameter, "AzureBareMetalStorageInstanceBody" + ) - request = build_update_request( + _request = build_update_request( resource_group_name=resource_group_name, azure_bare_metal_storage_instance_name=azure_bare_metal_storage_instance_name, subscription_id=self._config.subscription_id, @@ -596,16 +565,14 @@ async def update( content_type=content_type, json=_json, content=_content, - template_url=self.update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -615,24 +582,21 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("AzureBareMetalStorageInstance", pipeline_response) + deserialized = self._deserialize("AzureBareMetalStorageInstance", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - update.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances/{azureBareMetalStorageInstanceName}" - } + return deserialized # type: ignore @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements + async def delete( self, resource_group_name: str, azure_bare_metal_storage_instance_name: str, **kwargs: Any ) -> None: """Delete an AzureBareMetalStorageInstance. - Delete an AzureBareMetalStorageInstance. + Deletes an Azure Bare Metal Storage Instance for the specified subscription, resource group, + and instance name. :param resource_group_name: The name of the resource group. The name is case insensitive. Required. @@ -640,12 +604,11 @@ async def delete( # pylint: disable=inconsistent-return-statements :param azure_bare_metal_storage_instance_name: Name of the Azure Bare Metal Storage Instance, also known as the ResourceName. Required. :type azure_bare_metal_storage_instance_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, @@ -659,21 +622,19 @@ async def delete( # pylint: disable=inconsistent-return-statements api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[None] = kwargs.pop("cls", None) - request = build_delete_request( + _request = build_delete_request( resource_group_name=resource_group_name, azure_bare_metal_storage_instance_name=azure_bare_metal_storage_instance_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) _stream = False pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -684,8 +645,4 @@ async def delete( # pylint: disable=inconsistent-return-statements raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: - return cls(pipeline_response, None, {}) - - delete.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances/{azureBareMetalStorageInstanceName}" - } + return cls(pipeline_response, None, {}) # type: ignore diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/_operations.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/_operations.py index 56173e6418db..12ec104a3704 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/_operations.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/aio/operations/_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,9 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +from collections.abc import MutableMapping from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar import urllib.parse +from azure.core import AsyncPipelineClient from azure.core.async_paging import AsyncItemPaged, AsyncList from azure.core.exceptions import ( ClientAuthenticationError, @@ -19,15 +20,15 @@ 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 ..._serialization import Deserializer, Serializer from ...operations._operations import build_list_request +from .._configuration import BareMetalInfrastructureClientConfiguration T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -47,10 +48,12 @@ class Operations: 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") + self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: BareMetalInfrastructureClientConfiguration = ( + input_args.pop(0) if input_args else kwargs.pop("config") + ) + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: @@ -58,7 +61,6 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: Gets a list of AzureBareMetal management 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.baremetalinfrastructure.models.Operation] @@ -70,7 +72,7 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -81,14 +83,12 @@ 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: # make call to next link with the client's api-version @@ -100,13 +100,12 @@ def prepare_request(next_link=None): } ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( + _request = HttpRequest( "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _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) @@ -116,11 +115,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=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -132,5 +131,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list.metadata = {"url": "/providers/Microsoft.BareMetalInfrastructure/operations"} diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/models/__init__.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/models/__init__.py index 97a61f1fb9fd..079693815e66 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/models/__init__.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/models/__init__.py @@ -5,51 +5,67 @@ # 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 AzureBareMetalInstance -from ._models_py3 import AzureBareMetalInstancesListResult -from ._models_py3 import AzureBareMetalStorageInstance -from ._models_py3 import AzureBareMetalStorageInstancesListResult -from ._models_py3 import Disk -from ._models_py3 import ErrorAdditionalInfo -from ._models_py3 import ErrorDetail -from ._models_py3 import ErrorResponse -from ._models_py3 import ForceState -from ._models_py3 import HardwareProfile -from ._models_py3 import NetworkInterface -from ._models_py3 import NetworkProfile -from ._models_py3 import OSProfile -from ._models_py3 import Operation -from ._models_py3 import OperationDisplay -from ._models_py3 import OperationListResult -from ._models_py3 import OperationStatus -from ._models_py3 import OperationStatusError -from ._models_py3 import Resource -from ._models_py3 import StorageBillingProperties -from ._models_py3 import StorageProfile -from ._models_py3 import StorageProperties -from ._models_py3 import SystemData -from ._models_py3 import Tags -from ._models_py3 import TrackedResource +from typing import TYPE_CHECKING -from ._bare_metal_infrastructure_client_enums import ActionType -from ._bare_metal_infrastructure_client_enums import AsyncOperationStatus -from ._bare_metal_infrastructure_client_enums import AzureBareMetalHardwareTypeNamesEnum -from ._bare_metal_infrastructure_client_enums import AzureBareMetalInstanceForcePowerState -from ._bare_metal_infrastructure_client_enums import AzureBareMetalInstancePowerStateEnum -from ._bare_metal_infrastructure_client_enums import AzureBareMetalInstanceSizeNamesEnum -from ._bare_metal_infrastructure_client_enums import AzureBareMetalProvisioningStatesEnum -from ._bare_metal_infrastructure_client_enums import CreatedByType -from ._bare_metal_infrastructure_client_enums import Origin -from ._bare_metal_infrastructure_client_enums import ProvisioningState +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + + +from ._models_py3 import ( # type: ignore + AzureBareMetalInstance, + AzureBareMetalInstancesListResult, + AzureBareMetalStorageInstance, + AzureBareMetalStorageInstanceBody, + AzureBareMetalStorageInstanceIdentity, + AzureBareMetalStorageInstancesListResult, + Disk, + ErrorAdditionalInfo, + ErrorDetail, + ErrorResponse, + ForceState, + HardwareProfile, + NetworkInterface, + NetworkProfile, + OSProfile, + Operation, + OperationDisplay, + OperationListResult, + OperationStatus, + OperationStatusError, + Resource, + StorageBillingProperties, + StorageProfile, + StorageProperties, + SystemData, + Tags, + TrackedResource, +) + +from ._bare_metal_infrastructure_client_enums import ( # type: ignore + ActionType, + AsyncOperationStatus, + AzureBareMetalHardwareTypeNamesEnum, + AzureBareMetalInstanceForcePowerState, + AzureBareMetalInstancePowerStateEnum, + AzureBareMetalInstanceSizeNamesEnum, + AzureBareMetalProvisioningStatesEnum, + CreatedByType, + Origin, + ProvisioningState, + ResourceIdentityType, +) 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__ = [ "AzureBareMetalInstance", "AzureBareMetalInstancesListResult", "AzureBareMetalStorageInstance", + "AzureBareMetalStorageInstanceBody", + "AzureBareMetalStorageInstanceIdentity", "AzureBareMetalStorageInstancesListResult", "Disk", "ErrorAdditionalInfo", @@ -82,6 +98,7 @@ "CreatedByType", "Origin", "ProvisioningState", + "ResourceIdentityType", ] -__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/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/models/_bare_metal_infrastructure_client_enums.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/models/_bare_metal_infrastructure_client_enums.py index 643668a220aa..220b62161110 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/models/_bare_metal_infrastructure_client_enums.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/models/_bare_metal_infrastructure_client_enums.py @@ -142,3 +142,13 @@ class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): DELETING = "Deleting" CANCELED = "Canceled" MIGRATING = "Migrating" + + +class ResourceIdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """The type of identity used for the Azure Bare Metal Storage Instance. The type 'SystemAssigned' + refers to an implicitly created identity. The type 'None' will remove any identities from the + Azure Bare Metal Storage Instance. + """ + + SYSTEM_ASSIGNED = "SystemAssigned" + NONE = "None" diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/models/_models_py3.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/models/_models_py3.py index 0cc4778e5856..27e0505b8b38 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/models/_models_py3.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/models/_models_py3.py @@ -1,5 +1,5 @@ +# pylint: disable=line-too-long,useless-suppression,too-many-lines # coding=utf-8 -# pylint: disable=too-many-lines # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. @@ -13,7 +13,6 @@ from .. import _serialization if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from .. import models as _models @@ -52,10 +51,10 @@ class Resource(_serialization.Model): def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.id = None - self.name = None - self.type = None - self.system_data = None + self.id: Optional[str] = None + self.name: Optional[str] = None + self.type: Optional[str] = None + self.system_data: Optional["_models.SystemData"] = None class TrackedResource(Resource): @@ -64,7 +63,7 @@ class TrackedResource(Resource): Variables are only populated by the server, and will be ignored when sending a request. - All required parameters must be populated in order to send to Azure. + All required parameters must be populated in order to send to server. :ivar id: Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}". @@ -112,12 +111,12 @@ def __init__(self, *, location: str, tags: Optional[Dict[str, str]] = None, **kw self.location = location -class AzureBareMetalInstance(TrackedResource): # pylint: disable=too-many-instance-attributes +class AzureBareMetalInstance(TrackedResource): """AzureBareMetal instance info on Azure (ARM properties and AzureBareMetal properties). Variables are only populated by the server, and will be ignored when sending a request. - All required parameters must be populated in order to send to Azure. + All required parameters must be populated in order to send to server. :ivar id: Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}". @@ -167,10 +166,6 @@ class AzureBareMetalInstance(TrackedResource): # pylint: disable=too-many-insta "type": {"readonly": True}, "system_data": {"readonly": True}, "location": {"required": True}, - "azure_bare_metal_instance_id": {"readonly": True}, - "power_state": {"readonly": True}, - "proximity_placement_group": {"readonly": True}, - "hw_revision": {"readonly": True}, "provisioning_state": {"readonly": True}, } @@ -202,6 +197,10 @@ def __init__( storage_profile: Optional["_models.StorageProfile"] = None, os_profile: Optional["_models.OSProfile"] = None, network_profile: Optional["_models.NetworkProfile"] = None, + azure_bare_metal_instance_id: Optional[str] = None, + power_state: Optional[Union[str, "_models.AzureBareMetalInstancePowerStateEnum"]] = None, + proximity_placement_group: Optional[str] = None, + hw_revision: Optional[str] = None, partner_node_id: Optional[str] = None, **kwargs: Any ) -> None: @@ -219,6 +218,16 @@ def __init__( :paramtype os_profile: ~azure.mgmt.baremetalinfrastructure.models.OSProfile :keyword network_profile: Specifies the network settings for the Azure Bare Metal Instance. :paramtype network_profile: ~azure.mgmt.baremetalinfrastructure.models.NetworkProfile + :keyword azure_bare_metal_instance_id: Specifies the Azure Bare Metal Instance unique ID. + :paramtype azure_bare_metal_instance_id: str + :keyword power_state: Resource power state. Known values are: "starting", "started", + "stopping", "stopped", "restarting", and "unknown". + :paramtype power_state: str or + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstancePowerStateEnum + :keyword proximity_placement_group: Resource proximity placement group. + :paramtype proximity_placement_group: str + :keyword hw_revision: Hardware revision of an Azure Bare Metal Instance. + :paramtype hw_revision: str :keyword partner_node_id: ARM ID of another AzureBareMetalInstance that will share a network with this AzureBareMetalInstance. :paramtype partner_node_id: str @@ -228,12 +237,12 @@ def __init__( self.storage_profile = storage_profile self.os_profile = os_profile self.network_profile = network_profile - self.azure_bare_metal_instance_id = None - self.power_state = None - self.proximity_placement_group = None - self.hw_revision = None + self.azure_bare_metal_instance_id = azure_bare_metal_instance_id + self.power_state = power_state + self.proximity_placement_group = proximity_placement_group + self.hw_revision = hw_revision self.partner_node_id = partner_node_id - self.provisioning_state = None + self.provisioning_state: Optional[Union[str, "_models.AzureBareMetalProvisioningStatesEnum"]] = None class AzureBareMetalInstancesListResult(_serialization.Model): @@ -274,7 +283,7 @@ class AzureBareMetalStorageInstance(TrackedResource): Variables are only populated by the server, and will be ignored when sending a request. - All required parameters must be populated in order to send to Azure. + All required parameters must be populated in order to send to server. :ivar id: Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}". @@ -291,6 +300,9 @@ class AzureBareMetalStorageInstance(TrackedResource): :vartype tags: dict[str, str] :ivar location: The geo-location where the resource lives. Required. :vartype location: str + :ivar identity: The identity of Azure Bare Metal Storage Instance, if configured. + :vartype identity: + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstanceIdentity :ivar azure_bare_metal_storage_instance_unique_identifier: Specifies the AzureBareMetaStorageInstance unique ID. :vartype azure_bare_metal_storage_instance_unique_identifier: str @@ -314,6 +326,7 @@ class AzureBareMetalStorageInstance(TrackedResource): "system_data": {"key": "systemData", "type": "SystemData"}, "tags": {"key": "tags", "type": "{str}"}, "location": {"key": "location", "type": "str"}, + "identity": {"key": "identity", "type": "AzureBareMetalStorageInstanceIdentity"}, "azure_bare_metal_storage_instance_unique_identifier": { "key": "properties.azureBareMetalStorageInstanceUniqueIdentifier", "type": "str", @@ -326,6 +339,7 @@ def __init__( *, location: str, tags: Optional[Dict[str, str]] = None, + identity: Optional["_models.AzureBareMetalStorageInstanceIdentity"] = None, azure_bare_metal_storage_instance_unique_identifier: Optional[str] = None, storage_properties: Optional["_models.StorageProperties"] = None, **kwargs: Any @@ -335,6 +349,9 @@ def __init__( :paramtype tags: dict[str, str] :keyword location: The geo-location where the resource lives. Required. :paramtype location: str + :keyword identity: The identity of Azure Bare Metal Storage Instance, if configured. + :paramtype identity: + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstanceIdentity :keyword azure_bare_metal_storage_instance_unique_identifier: Specifies the AzureBareMetaStorageInstance unique ID. :paramtype azure_bare_metal_storage_instance_unique_identifier: str @@ -343,10 +360,88 @@ def __init__( :paramtype storage_properties: ~azure.mgmt.baremetalinfrastructure.models.StorageProperties """ super().__init__(tags=tags, location=location, **kwargs) + self.identity = identity self.azure_bare_metal_storage_instance_unique_identifier = azure_bare_metal_storage_instance_unique_identifier self.storage_properties = storage_properties +class AzureBareMetalStorageInstanceBody(_serialization.Model): + """properties of body during PUT/PATCH for an AzureBareMetalStorageInstance. + + :ivar identity: The identity of Azure Bare Metal Storage Instance, if configured. + :vartype identity: + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstanceIdentity + :ivar tags: Tags field of the AzureBareMetal/AzureBareMetaStorage instance. + :vartype tags: dict[str, str] + """ + + _attribute_map = { + "identity": {"key": "identity", "type": "AzureBareMetalStorageInstanceIdentity"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + identity: Optional["_models.AzureBareMetalStorageInstanceIdentity"] = None, + tags: Optional[Dict[str, str]] = None, + **kwargs: Any + ) -> None: + """ + :keyword identity: The identity of Azure Bare Metal Storage Instance, if configured. + :paramtype identity: + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstanceIdentity + :keyword tags: Tags field of the AzureBareMetal/AzureBareMetaStorage instance. + :paramtype tags: dict[str, str] + """ + super().__init__(**kwargs) + self.identity = identity + self.tags = tags + + +class AzureBareMetalStorageInstanceIdentity(_serialization.Model): + """Identity for Azure Bare Metal Storage Instance. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar principal_id: The principal ID of Azure Bare Metal Storage Instance identity. This + property will only be provided for a system assigned identity. + :vartype principal_id: str + :ivar tenant_id: The tenant ID associated with the Azure Bare Metal Storage Instance. This + property will only be provided for a system assigned identity. + :vartype tenant_id: str + :ivar type: The type of identity used for the Azure Bare Metal Storage Instance. The type + 'SystemAssigned' refers to an implicitly created identity. The type 'None' will remove any + identities from the Azure Bare Metal Storage Instance. Known values are: "SystemAssigned" and + "None". + :vartype type: str or ~azure.mgmt.baremetalinfrastructure.models.ResourceIdentityType + """ + + _validation = { + "principal_id": {"readonly": True}, + "tenant_id": {"readonly": True}, + } + + _attribute_map = { + "principal_id": {"key": "principalId", "type": "str"}, + "tenant_id": {"key": "tenantId", "type": "str"}, + "type": {"key": "type", "type": "str"}, + } + + def __init__(self, *, type: Optional[Union[str, "_models.ResourceIdentityType"]] = None, **kwargs: Any) -> None: + """ + :keyword type: The type of identity used for the Azure Bare Metal Storage Instance. The type + 'SystemAssigned' refers to an implicitly created identity. The type 'None' will remove any + identities from the Azure Bare Metal Storage Instance. Known values are: "SystemAssigned" and + "None". + :paramtype type: str or ~azure.mgmt.baremetalinfrastructure.models.ResourceIdentityType + """ + super().__init__(**kwargs) + self.principal_id: Optional[str] = None + self.tenant_id: Optional[str] = None + self.type = type + + class AzureBareMetalStorageInstancesListResult(_serialization.Model): """The response from the Get AzureBareMetalStorageInstances operation. @@ -414,7 +509,7 @@ def __init__(self, *, name: Optional[str] = None, disk_size_gb: Optional[int] = super().__init__(**kwargs) self.name = name self.disk_size_gb = disk_size_gb - self.lun = None + self.lun: Optional[int] = None class ErrorAdditionalInfo(_serialization.Model): @@ -441,8 +536,8 @@ class ErrorAdditionalInfo(_serialization.Model): def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.type = None - self.info = None + self.type: Optional[str] = None + self.info: Optional[JSON] = None class ErrorDetail(_serialization.Model): @@ -481,11 +576,11 @@ class ErrorDetail(_serialization.Model): def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.code = None - self.message = None - self.target = None - self.details = None - self.additional_info = None + self.code: Optional[str] = None + self.message: Optional[str] = None + self.target: Optional[str] = None + self.details: Optional[List["_models.ErrorDetail"]] = None + self.additional_info: Optional[List["_models.ErrorAdditionalInfo"]] = None class ErrorResponse(_serialization.Model): @@ -542,8 +637,6 @@ def __init__( class HardwareProfile(_serialization.Model): """Specifies the hardware settings for the Azure Bare Metal Instance. - Variables are only populated by the server, and will be ignored when sending a request. - :ivar hardware_type: Name of the hardware type (vendor and/or their product name). Known values are: "Cisco_UCS", "HPE", and "SDFLEX". :vartype hardware_type: str or @@ -558,21 +651,35 @@ class HardwareProfile(_serialization.Model): ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstanceSizeNamesEnum """ - _validation = { - "hardware_type": {"readonly": True}, - "azure_bare_metal_instance_size": {"readonly": True}, - } - _attribute_map = { "hardware_type": {"key": "hardwareType", "type": "str"}, "azure_bare_metal_instance_size": {"key": "azureBareMetalInstanceSize", "type": "str"}, } - def __init__(self, **kwargs: Any) -> None: - """ """ + def __init__( + self, + *, + hardware_type: Optional[Union[str, "_models.AzureBareMetalHardwareTypeNamesEnum"]] = None, + azure_bare_metal_instance_size: Optional[Union[str, "_models.AzureBareMetalInstanceSizeNamesEnum"]] = None, + **kwargs: Any + ) -> None: + """ + :keyword hardware_type: Name of the hardware type (vendor and/or their product name). Known + values are: "Cisco_UCS", "HPE", and "SDFLEX". + :paramtype hardware_type: str or + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalHardwareTypeNamesEnum + :keyword azure_bare_metal_instance_size: Specifies the Azure Bare Metal Instance SKU. Known + values are: "S72m", "S144m", "S72", "S144", "S192", "S192m", "S192xm", "S96", "S112", "S224", + "S224m", "S224om", "S224oo", "S224oom", "S224ooo", "S384", "S384m", "S384xm", "S384xxm", + "S448", "S448m", "S448om", "S448oo", "S448oom", "S448ooo", "S448se", "S576m", "S576xm", "S672", + "S672m", "S672om", "S672oo", "S672oom", "S672ooo", "S768", "S768m", "S768xm", "S896", "S896m", + "S896om", "S896oo", "S896oom", "S896ooo", and "S960m". + :paramtype azure_bare_metal_instance_size: str or + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstanceSizeNamesEnum + """ super().__init__(**kwargs) - self.hardware_type = None - self.azure_bare_metal_instance_size = None + self.hardware_type = hardware_type + self.azure_bare_metal_instance_size = azure_bare_metal_instance_size class NetworkInterface(_serialization.Model): @@ -598,33 +705,35 @@ def __init__(self, *, ip_address: Optional[str] = None, **kwargs: Any) -> None: class NetworkProfile(_serialization.Model): """Specifies the network settings for the Azure Bare Metal Instance disks. - Variables are only populated by the server, and will be ignored when sending a request. - :ivar network_interfaces: Specifies the network interfaces for the Azure Bare Metal Instance. :vartype network_interfaces: list[~azure.mgmt.baremetalinfrastructure.models.NetworkInterface] :ivar circuit_id: Specifies the circuit id for connecting to express route. :vartype circuit_id: str """ - _validation = { - "circuit_id": {"readonly": True}, - } - _attribute_map = { "network_interfaces": {"key": "networkInterfaces", "type": "[NetworkInterface]"}, "circuit_id": {"key": "circuitId", "type": "str"}, } - def __init__(self, *, network_interfaces: Optional[List["_models.NetworkInterface"]] = None, **kwargs: Any) -> None: + def __init__( + self, + *, + network_interfaces: Optional[List["_models.NetworkInterface"]] = None, + circuit_id: Optional[str] = None, + **kwargs: Any + ) -> None: """ :keyword network_interfaces: Specifies the network interfaces for the Azure Bare Metal Instance. :paramtype network_interfaces: list[~azure.mgmt.baremetalinfrastructure.models.NetworkInterface] + :keyword circuit_id: Specifies the circuit id for connecting to express route. + :paramtype circuit_id: str """ super().__init__(**kwargs) self.network_interfaces = network_interfaces - self.circuit_id = None + self.circuit_id = circuit_id class Operation(_serialization.Model): @@ -670,11 +779,11 @@ def __init__(self, *, display: Optional["_models.OperationDisplay"] = None, **kw :paramtype display: ~azure.mgmt.baremetalinfrastructure.models.OperationDisplay """ super().__init__(**kwargs) - self.name = None - self.is_data_action = None + self.name: Optional[str] = None + self.is_data_action: Optional[bool] = None self.display = display - self.origin = None - self.action_type = None + self.origin: Optional[Union[str, "_models.Origin"]] = None + self.action_type: Optional[Union[str, "_models.ActionType"]] = None class OperationDisplay(_serialization.Model): @@ -713,10 +822,10 @@ class OperationDisplay(_serialization.Model): def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.provider = None - self.resource = None - self.operation = None - self.description = None + self.provider: Optional[str] = None + self.resource: Optional[str] = None + self.operation: Optional[str] = None + self.description: Optional[str] = None class OperationListResult(_serialization.Model): @@ -744,8 +853,8 @@ class OperationListResult(_serialization.Model): def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.value = None - self.next_link = None + self.value: Optional[List["_models.Operation"]] = None + self.next_link: Optional[str] = None class OperationStatus(_serialization.Model): @@ -825,8 +934,6 @@ def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, class OSProfile(_serialization.Model): """Specifies the operating system settings for the Azure Bare Metal instance. - Variables are only populated by the server, and will be ignored when sending a request. - :ivar computer_name: Specifies the host OS name of the Azure Bare Metal instance. :vartype computer_name: str :ivar os_type: This property allows you to specify the type of the OS. @@ -837,11 +944,6 @@ class OSProfile(_serialization.Model): :vartype ssh_public_key: str """ - _validation = { - "os_type": {"readonly": True}, - "version": {"readonly": True}, - } - _attribute_map = { "computer_name": {"key": "computerName", "type": "str"}, "os_type": {"key": "osType", "type": "str"}, @@ -850,18 +952,28 @@ class OSProfile(_serialization.Model): } def __init__( - self, *, computer_name: Optional[str] = None, ssh_public_key: Optional[str] = None, **kwargs: Any + self, + *, + computer_name: Optional[str] = None, + os_type: Optional[str] = None, + version: Optional[str] = None, + ssh_public_key: Optional[str] = None, + **kwargs: Any ) -> None: """ :keyword computer_name: Specifies the host OS name of the Azure Bare Metal instance. :paramtype computer_name: str + :keyword os_type: This property allows you to specify the type of the OS. + :paramtype os_type: str + :keyword version: Specifies version of operating system. + :paramtype version: str :keyword ssh_public_key: Specifies the SSH public key used to access the operating system. :paramtype ssh_public_key: str """ super().__init__(**kwargs) self.computer_name = computer_name - self.os_type = None - self.version = None + self.os_type = os_type + self.version = version self.ssh_public_key = ssh_public_key @@ -900,8 +1012,6 @@ def __init__( class StorageProfile(_serialization.Model): """Specifies the storage settings for the Azure Bare Metal instance disks. - Variables are only populated by the server, and will be ignored when sending a request. - :ivar nfs_ip_address: IP Address to connect to storage. :vartype nfs_ip_address: str :ivar os_disks: Specifies information about the operating system disk used by bare metal @@ -909,23 +1019,23 @@ class StorageProfile(_serialization.Model): :vartype os_disks: list[~azure.mgmt.baremetalinfrastructure.models.Disk] """ - _validation = { - "nfs_ip_address": {"readonly": True}, - } - _attribute_map = { "nfs_ip_address": {"key": "nfsIpAddress", "type": "str"}, "os_disks": {"key": "osDisks", "type": "[Disk]"}, } - def __init__(self, *, os_disks: Optional[List["_models.Disk"]] = None, **kwargs: Any) -> None: + def __init__( + self, *, nfs_ip_address: Optional[str] = None, os_disks: Optional[List["_models.Disk"]] = None, **kwargs: Any + ) -> None: """ + :keyword nfs_ip_address: IP Address to connect to storage. + :paramtype nfs_ip_address: str :keyword os_disks: Specifies information about the operating system disk used by bare metal instance. :paramtype os_disks: list[~azure.mgmt.baremetalinfrastructure.models.Disk] """ super().__init__(**kwargs) - self.nfs_ip_address = None + self.nfs_ip_address = nfs_ip_address self.os_disks = os_disks @@ -1070,7 +1180,7 @@ def __init__( class Tags(_serialization.Model): - """Tags field of the AzureBareMetal/AzureBareMetaStorage instance. + """Tags field of the AzureBareMetal/AzureBareMetalStorage instance. :ivar tags: Tags field of the AzureBareMetal/AzureBareMetaStorage instance. :vartype tags: dict[str, str] diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/__init__.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/__init__.py index 3e12b5ce7466..74cab9f97daf 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/__init__.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/__init__.py @@ -5,13 +5,19 @@ # 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 ._azure_bare_metal_instances_operations import AzureBareMetalInstancesOperations -from ._operations import Operations -from ._azure_bare_metal_storage_instances_operations import AzureBareMetalStorageInstancesOperations +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._azure_bare_metal_instances_operations import AzureBareMetalInstancesOperations # type: ignore +from ._operations import Operations # type: ignore +from ._azure_bare_metal_storage_instances_operations import AzureBareMetalStorageInstancesOperations # 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__ = [ @@ -19,5 +25,5 @@ "Operations", "AzureBareMetalStorageInstancesOperations", ] -__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/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/_azure_bare_metal_instances_operations.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/_azure_bare_metal_instances_operations.py index 652da703c420..bc775a0815af 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/_azure_bare_metal_instances_operations.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/_azure_bare_metal_instances_operations.py @@ -1,4 +1,4 @@ -# pylint: disable=too-many-lines +# pylint: disable=line-too-long,useless-suppression,too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,31 +6,34 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +from collections.abc import MutableMapping from io import IOBase -from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, cast, overload +from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, TypeVar, Union, cast, overload import urllib.parse +from azure.core import PipelineClient from azure.core.exceptions import ( ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, map_error, ) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse -from azure.core.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 from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models -from .._serialization import Serializer -from .._vendor import _convert_request +from .._configuration import BareMetalInfrastructureClientConfiguration +from .._serialization import Deserializer, Serializer T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -45,14 +48,14 @@ def build_start_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-04-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}/start", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), "resourceGroupName": _SERIALIZER.url( @@ -80,7 +83,7 @@ def build_restart_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-04-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -88,7 +91,7 @@ def build_restart_request( _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}/restart", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), "resourceGroupName": _SERIALIZER.url( @@ -118,14 +121,14 @@ def build_shutdown_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-04-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}/shutdown", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), "resourceGroupName": _SERIALIZER.url( @@ -151,13 +154,13 @@ def build_list_by_subscription_request(subscription_id: str, **kwargs: Any) -> H _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-04-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances" - ) # pylint: disable=line-too-long + ) path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } @@ -177,14 +180,14 @@ def build_list_by_resource_group_request(resource_group_name: str, subscription_ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-04-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), "resourceGroupName": _SERIALIZER.url( @@ -209,14 +212,14 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-04-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), "resourceGroupName": _SERIALIZER.url( @@ -238,13 +241,51 @@ def build_get_request( return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) +def build_create_request( + resource_group_name: str, azure_bare_metal_instance_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "azureBareMetalInstanceName": _SERIALIZER.url( + "azure_bare_metal_instance_name", azure_bare_metal_instance_name, "str", pattern=r"^[a-zA-Z0-9]+$" + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + def build_update_request( resource_group_name: str, azure_bare_metal_instance_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-04-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -252,7 +293,7 @@ def build_update_request( _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), "resourceGroupName": _SERIALIZER.url( @@ -276,6 +317,41 @@ def build_update_request( return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) +def build_delete_request( + resource_group_name: str, azure_bare_metal_instance_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}", + ) + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1 + ), + "azureBareMetalInstanceName": _SERIALIZER.url( + "azure_bare_metal_instance_name", azure_bare_metal_instance_name, "str", pattern=r"^[a-zA-Z0-9]+$" + ), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) + + class AzureBareMetalInstancesOperations: """ .. warning:: @@ -290,15 +366,17 @@ class AzureBareMetalInstancesOperations: 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") + self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: BareMetalInfrastructureClientConfiguration = ( + input_args.pop(0) if input_args else kwargs.pop("config") + ) + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") def _start_initial( self, resource_group_name: str, azure_bare_metal_instance_name: str, **kwargs: Any - ) -> Optional[_models.OperationStatus]: - error_map = { + ) -> Iterator[bytes]: + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -310,48 +388,45 @@ def _start_initial( _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) - cls: ClsType[Optional[_models.OperationStatus]] = kwargs.pop("cls", None) + cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - request = build_start_request( + _request = build_start_request( resource_group_name=resource_group_name, azure_bare_metal_instance_name=azure_bare_metal_instance_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._start_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) - _stream = False + _decompress = kwargs.pop("decompress", True) + _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response if response.status_code not in [200, 202]: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = None response_headers = {} - if response.status_code == 200: - deserialized = self._deserialize("OperationStatus", pipeline_response) - if response.status_code == 202: response_headers["location"] = self._deserialize("str", response.headers.get("location")) - if cls: - return cls(pipeline_response, deserialized, response_headers) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) - return deserialized + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore - _start_initial.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}/start" - } + return deserialized # type: ignore @distributed_trace def begin_start( @@ -367,14 +442,6 @@ def begin_start( :param azure_bare_metal_instance_name: Name of the Azure Bare Metal Instance, also known as the ResourceName. Required. :type azure_bare_metal_instance_name: 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 OperationStatus or the result of cls(response) :rtype: @@ -399,12 +466,13 @@ def begin_start( 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("OperationStatus", pipeline_response) + deserialized = self._deserialize("OperationStatus", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore return deserialized if polling is True: @@ -416,26 +484,24 @@ def get_long_running_output(pipeline_response): else: polling_method = polling if cont_token: - return LROPoller.from_continuation_token( + return LROPoller[_models.OperationStatus].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_start.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}/start" - } + return LROPoller[_models.OperationStatus]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) def _restart_initial( self, resource_group_name: str, azure_bare_metal_instance_name: str, - force_parameter: Optional[Union[_models.ForceState, IO]] = None, + force_parameter: Optional[Union[_models.ForceState, IO[bytes]]] = None, **kwargs: Any - ) -> Optional[_models.OperationStatus]: - error_map = { + ) -> Iterator[bytes]: + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -448,7 +514,7 @@ def _restart_initial( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Optional[_models.OperationStatus]] = kwargs.pop("cls", None) + cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -461,7 +527,7 @@ def _restart_initial( else: _json = None - request = build_restart_request( + _request = build_restart_request( resource_group_name=resource_group_name, azure_bare_metal_instance_name=azure_bare_metal_instance_name, subscription_id=self._config.subscription_id, @@ -469,41 +535,38 @@ def _restart_initial( content_type=content_type, json=_json, content=_content, - template_url=self._restart_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) - _stream = False + _decompress = kwargs.pop("decompress", True) + _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response if response.status_code not in [200, 202]: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = None response_headers = {} - if response.status_code == 200: - deserialized = self._deserialize("OperationStatus", pipeline_response) - if response.status_code == 202: response_headers["location"] = self._deserialize("str", response.headers.get("location")) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) + if cls: - return cls(pipeline_response, deserialized, response_headers) + return cls(pipeline_response, deserialized, response_headers) # type: ignore - return deserialized - - _restart_initial.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}/restart" - } + return deserialized # type: ignore @overload def begin_restart( @@ -532,14 +595,6 @@ def begin_restart( :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 OperationStatus or the result of cls(response) :rtype: @@ -552,7 +607,7 @@ def begin_restart( self, resource_group_name: str, azure_bare_metal_instance_name: str, - force_parameter: Optional[IO] = None, + force_parameter: Optional[IO[bytes]] = None, *, content_type: str = "application/json", **kwargs: Any @@ -570,18 +625,10 @@ def begin_restart( :param force_parameter: When set to 'active', this parameter empowers the server with the ability to forcefully terminate and halt any existing processes that may be running on the server. Default value is None. - :type force_parameter: IO + :type force_parameter: 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 OperationStatus or the result of cls(response) :rtype: @@ -594,7 +641,7 @@ def begin_restart( self, resource_group_name: str, azure_bare_metal_instance_name: str, - force_parameter: Optional[Union[_models.ForceState, IO]] = None, + force_parameter: Optional[Union[_models.ForceState, IO[bytes]]] = None, **kwargs: Any ) -> LROPoller[_models.OperationStatus]: """Restart a Bare Metal Instance. @@ -609,19 +656,8 @@ def begin_restart( :type azure_bare_metal_instance_name: str :param force_parameter: When set to 'active', this parameter empowers the server with the ability to forcefully terminate and halt any existing processes that may be running on the - server. Is either a ForceState type or a IO type. Default value is None. - :type force_parameter: ~azure.mgmt.baremetalinfrastructure.models.ForceState 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. + server. Is either a ForceState type or a IO[bytes] type. Default value is None. + :type force_parameter: ~azure.mgmt.baremetalinfrastructure.models.ForceState or IO[bytes] :return: An instance of LROPoller that returns either OperationStatus or the result of cls(response) :rtype: @@ -649,12 +685,13 @@ def begin_restart( 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("OperationStatus", pipeline_response) + deserialized = self._deserialize("OperationStatus", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore return deserialized if polling is True: @@ -666,22 +703,20 @@ def get_long_running_output(pipeline_response): else: polling_method = polling if cont_token: - return LROPoller.from_continuation_token( + return LROPoller[_models.OperationStatus].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_restart.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}/restart" - } + return LROPoller[_models.OperationStatus]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) def _shutdown_initial( self, resource_group_name: str, azure_bare_metal_instance_name: str, **kwargs: Any - ) -> Optional[_models.OperationStatus]: - error_map = { + ) -> Iterator[bytes]: + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -693,48 +728,45 @@ def _shutdown_initial( _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) - cls: ClsType[Optional[_models.OperationStatus]] = kwargs.pop("cls", None) + cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - request = build_shutdown_request( + _request = build_shutdown_request( resource_group_name=resource_group_name, azure_bare_metal_instance_name=azure_bare_metal_instance_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._shutdown_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) - _stream = False + _decompress = kwargs.pop("decompress", True) + _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response if response.status_code not in [200, 202]: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = None response_headers = {} - if response.status_code == 200: - deserialized = self._deserialize("OperationStatus", pipeline_response) - if response.status_code == 202: response_headers["location"] = self._deserialize("str", response.headers.get("location")) - if cls: - return cls(pipeline_response, deserialized, response_headers) + deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) - return deserialized + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore - _shutdown_initial.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}/shutdown" - } + return deserialized # type: ignore @distributed_trace def begin_shutdown( @@ -750,14 +782,6 @@ def begin_shutdown( :param azure_bare_metal_instance_name: Name of the Azure Bare Metal Instance, also known as the ResourceName. Required. :type azure_bare_metal_instance_name: 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 OperationStatus or the result of cls(response) :rtype: @@ -782,12 +806,13 @@ def begin_shutdown( 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("OperationStatus", pipeline_response) + deserialized = self._deserialize("OperationStatus", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore return deserialized if polling is True: @@ -799,17 +824,15 @@ def get_long_running_output(pipeline_response): else: polling_method = polling if cont_token: - return LROPoller.from_continuation_token( + return LROPoller[_models.OperationStatus].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_shutdown.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}/shutdown" - } + return LROPoller[_models.OperationStatus]( + self._client, raw_result, get_long_running_output, polling_method # type: ignore + ) @distributed_trace def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.AzureBareMetalInstance"]: @@ -818,7 +841,6 @@ def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.AzureBareMeta Returns a list of Azure Bare Metal Instances in the specified subscription. The operations returns various properties of each Azure Bare Metal Instance. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either AzureBareMetalInstance or the result of cls(response) :rtype: @@ -831,7 +853,7 @@ def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.AzureBareMeta api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[_models.AzureBareMetalInstancesListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -842,15 +864,13 @@ def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.AzureBareMeta def prepare_request(next_link=None): if not next_link: - request = build_list_by_subscription_request( + _request = build_list_by_subscription_request( subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -862,13 +882,12 @@ def prepare_request(next_link=None): } ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( + _request = HttpRequest( "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request def extract_data(pipeline_response): deserialized = self._deserialize("AzureBareMetalInstancesListResult", pipeline_response) @@ -878,11 +897,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=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -895,10 +914,6 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_subscription.metadata = { - "url": "/subscriptions/{subscriptionId}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances" - } - @distributed_trace def list_by_resource_group( self, resource_group_name: str, **kwargs: Any @@ -911,7 +926,6 @@ def list_by_resource_group( :param resource_group_name: The name of the resource group. The name is case insensitive. Required. :type resource_group_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either AzureBareMetalInstance or the result of cls(response) :rtype: @@ -924,7 +938,7 @@ def list_by_resource_group( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[_models.AzureBareMetalInstancesListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -935,16 +949,14 @@ def list_by_resource_group( def prepare_request(next_link=None): if not next_link: - request = build_list_by_resource_group_request( + _request = build_list_by_resource_group_request( resource_group_name=resource_group_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -956,13 +968,12 @@ def prepare_request(next_link=None): } ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( + _request = HttpRequest( "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request def extract_data(pipeline_response): deserialized = self._deserialize("AzureBareMetalInstancesListResult", pipeline_response) @@ -972,11 +983,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=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -989,10 +1000,6 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_resource_group.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances" - } - @distributed_trace def get( self, resource_group_name: str, azure_bare_metal_instance_name: str, **kwargs: Any @@ -1008,12 +1015,11 @@ def get( :param azure_bare_metal_instance_name: Name of the Azure Bare Metal Instance, also known as the ResourceName. Required. :type azure_bare_metal_instance_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: AzureBareMetalInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1027,21 +1033,19 @@ def get( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[_models.AzureBareMetalInstance] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, azure_bare_metal_instance_name=azure_bare_metal_instance_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -1051,16 +1055,151 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("AzureBareMetalInstance", pipeline_response) + deserialized = self._deserialize("AzureBareMetalInstance", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized + return deserialized # type: ignore - get.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}" - } + @overload + def create( + self, + resource_group_name: str, + azure_bare_metal_instance_name: str, + request_body_parameters: _models.AzureBareMetalInstance, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AzureBareMetalInstance: + """Creates an Azure Bare Metal Instance for the specified subscription, resource group, and + instance name. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param azure_bare_metal_instance_name: Name of the Azure Bare Metal Instance, also known as the + ResourceName. Required. + :type azure_bare_metal_instance_name: str + :param request_body_parameters: Resource create parameters. Required. + :type request_body_parameters: + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: AzureBareMetalInstance or the result of cls(response) + :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create( + self, + resource_group_name: str, + azure_bare_metal_instance_name: str, + request_body_parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AzureBareMetalInstance: + """Creates an Azure Bare Metal Instance for the specified subscription, resource group, and + instance name. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param azure_bare_metal_instance_name: Name of the Azure Bare Metal Instance, also known as the + ResourceName. Required. + :type azure_bare_metal_instance_name: str + :param request_body_parameters: Resource create parameters. Required. + :type request_body_parameters: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: AzureBareMetalInstance or the result of cls(response) + :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create( + self, + resource_group_name: str, + azure_bare_metal_instance_name: str, + request_body_parameters: Union[_models.AzureBareMetalInstance, IO[bytes]], + **kwargs: Any + ) -> _models.AzureBareMetalInstance: + """Creates an Azure Bare Metal Instance for the specified subscription, resource group, and + instance name. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param azure_bare_metal_instance_name: Name of the Azure Bare Metal Instance, also known as the + ResourceName. Required. + :type azure_bare_metal_instance_name: str + :param request_body_parameters: Resource create parameters. Is either a AzureBareMetalInstance + type or a IO[bytes] type. Required. + :type request_body_parameters: + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance or IO[bytes] + :return: AzureBareMetalInstance or the result of cls(response) + :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.AzureBareMetalInstance] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(request_body_parameters, (IOBase, bytes)): + _content = request_body_parameters + else: + _json = self._serialize.body(request_body_parameters, "AzureBareMetalInstance") + + _request = build_create_request( + resource_group_name=resource_group_name, + azure_bare_metal_instance_name=azure_bare_metal_instance_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("AzureBareMetalInstance", pipeline_response.http_response) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore @overload def update( @@ -1088,7 +1227,6 @@ def update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: AzureBareMetalInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance :raises ~azure.core.exceptions.HttpResponseError: @@ -1099,7 +1237,7 @@ def update( self, resource_group_name: str, azure_bare_metal_instance_name: str, - tags_parameter: IO, + tags_parameter: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -1116,11 +1254,10 @@ def update( ResourceName. Required. :type azure_bare_metal_instance_name: str :param tags_parameter: Request body that only contains the new Tags field. Required. - :type tags_parameter: IO + :type tags_parameter: 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: AzureBareMetalInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance :raises ~azure.core.exceptions.HttpResponseError: @@ -1131,7 +1268,7 @@ def update( self, resource_group_name: str, azure_bare_metal_instance_name: str, - tags_parameter: Union[_models.Tags, IO], + tags_parameter: Union[_models.Tags, IO[bytes]], **kwargs: Any ) -> _models.AzureBareMetalInstance: """Patches the Tags field of a Azure Bare Metal Instance. @@ -1146,17 +1283,13 @@ def update( ResourceName. Required. :type azure_bare_metal_instance_name: str :param tags_parameter: Request body that only contains the new Tags field. Is either a Tags - type or a IO type. Required. - :type tags_parameter: ~azure.mgmt.baremetalinfrastructure.models.Tags 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 + type or a IO[bytes] type. Required. + :type tags_parameter: ~azure.mgmt.baremetalinfrastructure.models.Tags or IO[bytes] :return: AzureBareMetalInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalInstance :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -1179,7 +1312,7 @@ def update( else: _json = self._serialize.body(tags_parameter, "Tags") - request = build_update_request( + _request = build_update_request( resource_group_name=resource_group_name, azure_bare_metal_instance_name=azure_bare_metal_instance_name, subscription_id=self._config.subscription_id, @@ -1187,16 +1320,14 @@ def update( content_type=content_type, json=_json, content=_content, - template_url=self.update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -1206,13 +1337,65 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("AzureBareMetalInstance", pipeline_response) + deserialized = self._deserialize("AzureBareMetalInstance", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized + return deserialized # type: ignore - update.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalInstances/{azureBareMetalInstanceName}" - } + @distributed_trace + def delete( # pylint: disable=inconsistent-return-statements + self, resource_group_name: str, azure_bare_metal_instance_name: str, **kwargs: Any + ) -> None: + """Deletes an Azure Bare Metal Instance for the specified subscription, resource group, and + instance name. + + :param resource_group_name: The name of the resource group. The name is case insensitive. + Required. + :type resource_group_name: str + :param azure_bare_metal_instance_name: Name of the Azure Bare Metal Instance, also known as the + ResourceName. Required. + :type azure_bare_metal_instance_name: str + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_delete_request( + resource_group_name=resource_group_name, + azure_bare_metal_instance_name=azure_bare_metal_instance_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + headers=_headers, + params=_params, + ) + _request.url = self._client.format_url(_request.url) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 204]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if cls: + return cls(pipeline_response, None, {}) # type: ignore diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/_azure_bare_metal_storage_instances_operations.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/_azure_bare_metal_storage_instances_operations.py index cf5c6ee2f762..124d4455318e 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/_azure_bare_metal_storage_instances_operations.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/_azure_bare_metal_storage_instances_operations.py @@ -1,4 +1,4 @@ -# pylint: disable=too-many-lines +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +6,12 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +from collections.abc import MutableMapping from io import IOBase from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload import urllib.parse +from azure.core import PipelineClient from azure.core.exceptions import ( ClientAuthenticationError, HttpResponseError, @@ -20,15 +22,14 @@ ) 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 +from .._configuration import BareMetalInfrastructureClientConfiguration +from .._serialization import Deserializer, Serializer T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -41,14 +42,14 @@ def build_list_by_subscription_request(subscription_id: str, **kwargs: Any) -> H _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-04-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } @@ -68,14 +69,14 @@ def build_list_by_resource_group_request(resource_group_name: str, subscription_ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-04-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), "resourceGroupName": _SERIALIZER.url( @@ -100,14 +101,14 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-04-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances/{azureBareMetalStorageInstanceName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), "resourceGroupName": _SERIALIZER.url( @@ -135,7 +136,7 @@ def build_create_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-04-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -143,7 +144,7 @@ def build_create_request( _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances/{azureBareMetalStorageInstanceName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), "resourceGroupName": _SERIALIZER.url( @@ -173,7 +174,7 @@ def build_update_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-04-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") @@ -181,7 +182,7 @@ def build_update_request( _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances/{azureBareMetalStorageInstanceName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), "resourceGroupName": _SERIALIZER.url( @@ -211,14 +212,14 @@ def build_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-04-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances/{azureBareMetalStorageInstanceName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), "resourceGroupName": _SERIALIZER.url( @@ -254,10 +255,12 @@ class AzureBareMetalStorageInstancesOperations: 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") + self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: BareMetalInfrastructureClientConfiguration = ( + input_args.pop(0) if input_args else kwargs.pop("config") + ) + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.AzureBareMetalStorageInstance"]: @@ -266,7 +269,6 @@ def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.AzureBareMeta Gets a list of AzureBareMetalStorage instances in the specified subscription. The operations returns various properties of each Azure Bare Metal Instance. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either AzureBareMetalStorageInstance or the result of cls(response) :rtype: @@ -279,7 +281,7 @@ def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.AzureBareMeta api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[_models.AzureBareMetalStorageInstancesListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -290,15 +292,13 @@ def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.AzureBareMeta def prepare_request(next_link=None): if not next_link: - request = build_list_by_subscription_request( + _request = build_list_by_subscription_request( subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_subscription.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -310,13 +310,12 @@ def prepare_request(next_link=None): } ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( + _request = HttpRequest( "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request def extract_data(pipeline_response): deserialized = self._deserialize("AzureBareMetalStorageInstancesListResult", pipeline_response) @@ -326,11 +325,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=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -343,10 +342,6 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_subscription.metadata = { - "url": "/subscriptions/{subscriptionId}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances" - } - @distributed_trace def list_by_resource_group( self, resource_group_name: str, **kwargs: Any @@ -360,7 +355,6 @@ def list_by_resource_group( :param resource_group_name: The name of the resource group. The name is case insensitive. Required. :type resource_group_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either AzureBareMetalStorageInstance or the result of cls(response) :rtype: @@ -373,7 +367,7 @@ def list_by_resource_group( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[_models.AzureBareMetalStorageInstancesListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -384,16 +378,14 @@ def list_by_resource_group( def prepare_request(next_link=None): if not next_link: - request = build_list_by_resource_group_request( + _request = build_list_by_resource_group_request( resource_group_name=resource_group_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -405,13 +397,12 @@ def prepare_request(next_link=None): } ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( + _request = HttpRequest( "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request def extract_data(pipeline_response): deserialized = self._deserialize("AzureBareMetalStorageInstancesListResult", pipeline_response) @@ -421,11 +412,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=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -438,10 +429,6 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_resource_group.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances" - } - @distributed_trace def get( self, resource_group_name: str, azure_bare_metal_storage_instance_name: str, **kwargs: Any @@ -457,12 +444,11 @@ def get( :param azure_bare_metal_storage_instance_name: Name of the Azure Bare Metal Storage Instance, also known as the ResourceName. Required. :type azure_bare_metal_storage_instance_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: AzureBareMetalStorageInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -476,21 +462,19 @@ def get( api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[_models.AzureBareMetalStorageInstance] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, azure_bare_metal_storage_instance_name=azure_bare_metal_storage_instance_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -500,16 +484,12 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("AzureBareMetalStorageInstance", pipeline_response) + deserialized = self._deserialize("AzureBareMetalStorageInstance", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - get.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances/{azureBareMetalStorageInstanceName}" - } + return deserialized # type: ignore @overload def create( @@ -523,7 +503,8 @@ def create( ) -> _models.AzureBareMetalStorageInstance: """Create an azure bare metal storage resource. - Create an azure bare metal storage resource. + Creates an Azure Bare Metal Storage Instance for the specified subscription, resource group, + and instance name. :param resource_group_name: The name of the resource group. The name is case insensitive. Required. @@ -537,7 +518,6 @@ def 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 :return: AzureBareMetalStorageInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance :raises ~azure.core.exceptions.HttpResponseError: @@ -548,14 +528,15 @@ def create( self, resource_group_name: str, azure_bare_metal_storage_instance_name: str, - request_body_parameters: IO, + request_body_parameters: IO[bytes], *, content_type: str = "application/json", **kwargs: Any ) -> _models.AzureBareMetalStorageInstance: """Create an azure bare metal storage resource. - Create an azure bare metal storage resource. + Creates an Azure Bare Metal Storage Instance for the specified subscription, resource group, + and instance name. :param resource_group_name: The name of the resource group. The name is case insensitive. Required. @@ -564,11 +545,10 @@ def create( also known as the ResourceName. Required. :type azure_bare_metal_storage_instance_name: str :param request_body_parameters: request body for put call. Required. - :type request_body_parameters: IO + :type request_body_parameters: IO[bytes] :keyword content_type: Body Parameter content-type. Content type parameter for binary body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: AzureBareMetalStorageInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance :raises ~azure.core.exceptions.HttpResponseError: @@ -579,12 +559,13 @@ def create( self, resource_group_name: str, azure_bare_metal_storage_instance_name: str, - request_body_parameters: Union[_models.AzureBareMetalStorageInstance, IO], + request_body_parameters: Union[_models.AzureBareMetalStorageInstance, IO[bytes]], **kwargs: Any ) -> _models.AzureBareMetalStorageInstance: """Create an azure bare metal storage resource. - Create an azure bare metal storage resource. + Creates an Azure Bare Metal Storage Instance for the specified subscription, resource group, + and instance name. :param resource_group_name: The name of the resource group. The name is case insensitive. Required. @@ -593,18 +574,14 @@ def create( also known as the ResourceName. Required. :type azure_bare_metal_storage_instance_name: str :param request_body_parameters: request body for put call. Is either a - AzureBareMetalStorageInstance type or a IO type. Required. + AzureBareMetalStorageInstance type or a IO[bytes] type. Required. :type request_body_parameters: - ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance 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 + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance or IO[bytes] :return: AzureBareMetalStorageInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -627,7 +604,7 @@ def create( else: _json = self._serialize.body(request_body_parameters, "AzureBareMetalStorageInstance") - request = build_create_request( + _request = build_create_request( resource_group_name=resource_group_name, azure_bare_metal_storage_instance_name=azure_bare_metal_storage_instance_name, subscription_id=self._config.subscription_id, @@ -635,16 +612,14 @@ def create( content_type=content_type, json=_json, content=_content, - template_url=self.create.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _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 + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -654,34 +629,26 @@ def create( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - if response.status_code == 200: - deserialized = self._deserialize("AzureBareMetalStorageInstance", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("AzureBareMetalStorageInstance", pipeline_response) + deserialized = self._deserialize("AzureBareMetalStorageInstance", pipeline_response.http_response) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore return deserialized # type: ignore - create.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances/{azureBareMetalStorageInstanceName}" - } - @overload def update( self, resource_group_name: str, azure_bare_metal_storage_instance_name: str, - tags_parameter: _models.Tags, + azure_bare_metal_storage_instance_body_parameter: _models.AzureBareMetalStorageInstanceBody, *, content_type: str = "application/json", **kwargs: Any ) -> _models.AzureBareMetalStorageInstance: - """Patches the Tags field of a Azure Bare Metal Storage instance. + """Patches the Tags field of a Azure BareMetalStorage instance. - Patches the Tags field of a Azure Bare Metal Storage instance for the specified subscription, + Patches the Tags field of a Azure BareMetalStorage instance for the specified subscription, resource group, and instance name. :param resource_group_name: The name of the resource group. The name is case insensitive. @@ -690,12 +657,13 @@ def update( :param azure_bare_metal_storage_instance_name: Name of the Azure Bare Metal Storage Instance, also known as the ResourceName. Required. :type azure_bare_metal_storage_instance_name: str - :param tags_parameter: Request body that only contains the new Tags field. Required. - :type tags_parameter: ~azure.mgmt.baremetalinfrastructure.models.Tags + :param azure_bare_metal_storage_instance_body_parameter: Request body that only contains the + Tags and Identity Field. Required. + :type azure_bare_metal_storage_instance_body_parameter: + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstanceBody :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: AzureBareMetalStorageInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance :raises ~azure.core.exceptions.HttpResponseError: @@ -706,14 +674,14 @@ def update( self, resource_group_name: str, azure_bare_metal_storage_instance_name: str, - tags_parameter: IO, + azure_bare_metal_storage_instance_body_parameter: IO[bytes], *, content_type: str = "application/json", **kwargs: Any ) -> _models.AzureBareMetalStorageInstance: - """Patches the Tags field of a Azure Bare Metal Storage instance. + """Patches the Tags field of a Azure BareMetalStorage instance. - Patches the Tags field of a Azure Bare Metal Storage instance for the specified subscription, + Patches the Tags field of a Azure BareMetalStorage instance for the specified subscription, resource group, and instance name. :param resource_group_name: The name of the resource group. The name is case insensitive. @@ -722,12 +690,12 @@ def update( :param azure_bare_metal_storage_instance_name: Name of the Azure Bare Metal Storage Instance, also known as the ResourceName. Required. :type azure_bare_metal_storage_instance_name: str - :param tags_parameter: Request body that only contains the new Tags field. Required. - :type tags_parameter: IO + :param azure_bare_metal_storage_instance_body_parameter: Request body that only contains the + Tags and Identity Field. Required. + :type azure_bare_metal_storage_instance_body_parameter: 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: AzureBareMetalStorageInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance :raises ~azure.core.exceptions.HttpResponseError: @@ -738,12 +706,12 @@ def update( self, resource_group_name: str, azure_bare_metal_storage_instance_name: str, - tags_parameter: Union[_models.Tags, IO], + azure_bare_metal_storage_instance_body_parameter: Union[_models.AzureBareMetalStorageInstanceBody, IO[bytes]], **kwargs: Any ) -> _models.AzureBareMetalStorageInstance: - """Patches the Tags field of a Azure Bare Metal Storage instance. + """Patches the Tags field of a Azure BareMetalStorage instance. - Patches the Tags field of a Azure Bare Metal Storage instance for the specified subscription, + Patches the Tags field of a Azure BareMetalStorage instance for the specified subscription, resource group, and instance name. :param resource_group_name: The name of the resource group. The name is case insensitive. @@ -752,18 +720,16 @@ def update( :param azure_bare_metal_storage_instance_name: Name of the Azure Bare Metal Storage Instance, also known as the ResourceName. Required. :type azure_bare_metal_storage_instance_name: str - :param tags_parameter: Request body that only contains the new Tags field. Is either a Tags - type or a IO type. Required. - :type tags_parameter: ~azure.mgmt.baremetalinfrastructure.models.Tags 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 azure_bare_metal_storage_instance_body_parameter: Request body that only contains the + Tags and Identity Field. Is either a AzureBareMetalStorageInstanceBody type or a IO[bytes] + type. Required. + :type azure_bare_metal_storage_instance_body_parameter: + ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstanceBody or IO[bytes] :return: AzureBareMetalStorageInstance or the result of cls(response) :rtype: ~azure.mgmt.baremetalinfrastructure.models.AzureBareMetalStorageInstance :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -781,12 +747,14 @@ def update( content_type = content_type or "application/json" _json = None _content = None - if isinstance(tags_parameter, (IOBase, bytes)): - _content = tags_parameter + if isinstance(azure_bare_metal_storage_instance_body_parameter, (IOBase, bytes)): + _content = azure_bare_metal_storage_instance_body_parameter else: - _json = self._serialize.body(tags_parameter, "Tags") + _json = self._serialize.body( + azure_bare_metal_storage_instance_body_parameter, "AzureBareMetalStorageInstanceBody" + ) - request = build_update_request( + _request = build_update_request( resource_group_name=resource_group_name, azure_bare_metal_storage_instance_name=azure_bare_metal_storage_instance_name, subscription_id=self._config.subscription_id, @@ -794,16 +762,14 @@ def update( content_type=content_type, json=_json, content=_content, - template_url=self.update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -813,16 +779,12 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("AzureBareMetalStorageInstance", pipeline_response) + deserialized = self._deserialize("AzureBareMetalStorageInstance", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - update.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances/{azureBareMetalStorageInstanceName}" - } + return deserialized # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -830,7 +792,8 @@ def delete( # pylint: disable=inconsistent-return-statements ) -> None: """Delete an AzureBareMetalStorageInstance. - Delete an AzureBareMetalStorageInstance. + Deletes an Azure Bare Metal Storage Instance for the specified subscription, resource group, + and instance name. :param resource_group_name: The name of the resource group. The name is case insensitive. Required. @@ -838,12 +801,11 @@ def delete( # pylint: disable=inconsistent-return-statements :param azure_bare_metal_storage_instance_name: Name of the Azure Bare Metal Storage Instance, also known as the ResourceName. Required. :type azure_bare_metal_storage_instance_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, @@ -857,21 +819,19 @@ def delete( # pylint: disable=inconsistent-return-statements api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[None] = kwargs.pop("cls", None) - request = build_delete_request( + _request = build_delete_request( resource_group_name=resource_group_name, azure_bare_metal_storage_instance_name=azure_bare_metal_storage_instance_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) + _request.url = self._client.format_url(_request.url) _stream = False pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -882,8 +842,4 @@ def delete( # pylint: disable=inconsistent-return-statements raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: - return cls(pipeline_response, None, {}) - - delete.metadata = { - "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.BareMetalInfrastructure/bareMetalStorageInstances/{azureBareMetalStorageInstanceName}" - } + return cls(pipeline_response, None, {}) # type: ignore diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/_operations.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/_operations.py index 97e808467e73..53721fe4bac0 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/_operations.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/azure/mgmt/baremetalinfrastructure/operations/_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,9 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +from collections.abc import MutableMapping from typing import Any, Callable, Dict, Iterable, Optional, TypeVar import urllib.parse +from azure.core import PipelineClient from azure.core.exceptions import ( ClientAuthenticationError, HttpResponseError, @@ -19,15 +20,14 @@ ) 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 +from .._configuration import BareMetalInfrastructureClientConfiguration +from .._serialization import Deserializer, Serializer T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -40,7 +40,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: str = kwargs.pop("api_version", _params.pop("api-version", "2023-08-04-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-08-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -69,10 +69,12 @@ class Operations: 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") + self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: BareMetalInfrastructureClientConfiguration = ( + input_args.pop(0) if input_args else kwargs.pop("config") + ) + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: @@ -80,7 +82,6 @@ def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: Gets a list of AzureBareMetal management 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.baremetalinfrastructure.models.Operation] :raises ~azure.core.exceptions.HttpResponseError: @@ -91,7 +92,7 @@ def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) cls: ClsType[_models.OperationListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -102,14 +103,12 @@ 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: # make call to next link with the client's api-version @@ -121,13 +120,12 @@ def prepare_request(next_link=None): } ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( + _request = HttpRequest( "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - request.method = "GET" - return request + _request.url = self._client.format_url(_request.url) + _request.method = "GET" + return _request def extract_data(pipeline_response): deserialized = self._deserialize("OperationListResult", pipeline_response) @@ -137,11 +135,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=_stream, **kwargs + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -153,5 +151,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list.metadata = {"url": "/providers/Microsoft.BareMetalInfrastructure/operations"} diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_create.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_create.py new file mode 100644 index 000000000000..42375d6b3264 --- /dev/null +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_create.py @@ -0,0 +1,65 @@ +# pylint: disable=line-too-long,useless-suppression +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from azure.identity import DefaultAzureCredential + +from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-baremetalinfrastructure +# USAGE + python azure_bare_metal_instances_create.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 = BareMetalInfrastructureClient( + credential=DefaultAzureCredential(), + subscription_id="f0f4887f-d13c-4943-a8ba-d7da28d2a3fd", + ) + + response = client.azure_bare_metal_instances.create( + resource_group_name="myResourceGroup", + azure_bare_metal_instance_name="myBMIInstance", + request_body_parameters={ + "location": "westus", + "properties": { + "azureBareMetalInstanceId": "23415635-4d7e-41dc-9598-8194f22c24e1", + "hardwareProfile": {"azureBareMetalInstanceSize": "S72", "hardwareType": "Cisco_UCS"}, + "hwRevision": "Rev 3", + "networkProfile": { + "circuitId": "/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.Network/expressRouteCircuit", + "networkInterfaces": [{"ipAddress": "100.100.100.100"}], + }, + "osProfile": { + "computerName": "myComputerName", + "osType": "SUSE", + "sshPublicKey": "{ssh-rsa public key}", + "version": "12 SP1", + }, + "powerState": "started", + "proximityPlacementGroup": "/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.Compute/proximityPlacementGroups/myplacementgroup", + "storageProfile": {"nfsIpAddress": "200.200.200.200"}, + }, + "tags": {"testkey": "testvalue"}, + }, + ) + print(response) + + +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalInstances_Create.json +if __name__ == "__main__": + main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_delete.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_delete.py new file mode 100644 index 000000000000..80166c04882e --- /dev/null +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_delete.py @@ -0,0 +1,42 @@ +# pylint: disable=line-too-long,useless-suppression +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from azure.identity import DefaultAzureCredential + +from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-baremetalinfrastructure +# USAGE + python azure_bare_metal_instances_delete.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 = BareMetalInfrastructureClient( + credential=DefaultAzureCredential(), + subscription_id="f0f4887f-d13c-4943-a8ba-d7da28d2a3fd", + ) + + client.azure_bare_metal_instances.delete( + resource_group_name="myResourceGroup", + azure_bare_metal_instance_name="myAzureBareMetalInstance", + ) + + +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalInstances_Delete.json +if __name__ == "__main__": + main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_get.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_get.py index 639d556a325e..ca265494d475 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_get.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_get.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -36,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalInstances_Get.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalInstances_Get.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_list_by_resource_group.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_list_by_resource_group.py index a007efe33512..312af9c17a7b 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_list_by_resource_group.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_list_by_resource_group.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -36,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalInstances_ListByResourceGroup.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalInstances_ListByResourceGroup.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_list_by_subscription.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_list_by_subscription.py index fb60715b392d..f16cee7fe17b 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_list_by_subscription.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_list_by_subscription.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -34,6 +36,6 @@ def main(): print(item) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalInstances_ListBySubscription.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalInstances_ListBySubscription.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_patch_tags.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_patch_tags.py index d9e4bfb7a2bc..e02477710f3b 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_patch_tags.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_patch_tags.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -37,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalInstances_PatchTags.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalInstances_PatchTags.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_patch_tags_delete.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_patch_tags_delete.py index 8ee6ef43609a..5cd9723358fd 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_patch_tags_delete.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_patch_tags_delete.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -37,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalInstances_PatchTags_Delete.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalInstances_PatchTags_Delete.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_restart.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_restart.py index d938e5973963..8e19dba4fc68 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_restart.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_restart.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -36,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalInstances_Restart.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalInstances_Restart.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_shutdown.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_shutdown.py index 2274310bfcc6..c1fae90269de 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_shutdown.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_shutdown.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -36,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalInstances_Shutdown.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalInstances_Shutdown.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_start.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_start.py index b6e2d6268f99..9bd9a94aa8eb 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_start.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_instances_start.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -36,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalInstances_Start.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalInstances_Start.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_operations_list.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_operations_list.py index 917ababea4f7..ab808abd4a3d 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_operations_list.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_operations_list.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -34,6 +36,6 @@ def main(): print(item) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalOperations_List.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalOperations_List.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_create.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_create.py index 3978f1bbb83e..f4e2877c29e2 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_create.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_create.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -40,7 +42,6 @@ def main(): "generation": "Gen4", "hardwareType": "NetApp", "offeringType": "EPIC", - "provisioningState": "Succeeded", "storageBillingProperties": {"azureBareMetalStorageInstanceSize": "", "billingMode": "PAYG"}, "storageType": "FC", "workloadType": "ODB", @@ -52,6 +53,6 @@ def main(): print(response) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalStorageInstances_Create.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalStorageInstances_Create.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_delete.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_delete.py index 35cb84f2fc34..31949c55a8a7 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_delete.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_delete.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -35,6 +37,6 @@ def main(): ) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalStorageInstances_Delete.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalStorageInstances_Delete.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_get.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_get.py index 10c7f4b56092..b4f30ced3098 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_get.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_get.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -36,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalStorageInstances_Get.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalStorageInstances_Get.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_list_by_resource_group.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_list_by_resource_group.py index 4b95132cc3dc..e67dee95101b 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_list_by_resource_group.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_list_by_resource_group.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -36,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalStorageInstances_ListByResourceGroup.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalStorageInstances_ListByResourceGroup.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_list_by_subscription.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_list_by_subscription.py index 89f849045a38..0300c64e98ee 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_list_by_subscription.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_list_by_subscription.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -34,6 +36,6 @@ def main(): print(item) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalStorageInstances_ListBySubscription.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalStorageInstances_ListBySubscription.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_patch_tags.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_patch_tags.py index d52d65603189..801d4bb1d05e 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_patch_tags.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_patch_tags.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -32,11 +34,14 @@ def main(): response = client.azure_bare_metal_storage_instances.update( resource_group_name="myResourceGroup", azure_bare_metal_storage_instance_name="myABMSInstance", - tags_parameter={"tags": {"testkey": "testvalue"}}, + azure_bare_metal_storage_instance_body_parameter={ + "identity": {"type": "SystemAssigned"}, + "tags": {"testkey": "testvalue"}, + }, ) print(response) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalStorageInstances_PatchTags.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalStorageInstances_PatchTags.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_patch_tags_delete.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_patch_tags_delete.py index 2f92e45ca3d0..6e3c8407251e 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_patch_tags_delete.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_samples/azure_bare_metal_storage_instances_patch_tags_delete.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,6 +8,7 @@ # -------------------------------------------------------------------------- from azure.identity import DefaultAzureCredential + from azure.mgmt.baremetalinfrastructure import BareMetalInfrastructureClient """ @@ -32,11 +34,14 @@ def main(): response = client.azure_bare_metal_storage_instances.update( resource_group_name="myResourceGroup", azure_bare_metal_storage_instance_name="myABMSInstance", - tags_parameter={"tags": {}}, + azure_bare_metal_storage_instance_body_parameter={ + "identity": {"type": "SystemAssigned"}, + "tags": {"testkey": "testvalue"}, + }, ) print(response) -# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2023-08-04-preview/examples/AzureBareMetalStorageInstances_PatchTags_Delete.json +# x-ms-original-file: specification/baremetalinfrastructure/resource-manager/Microsoft.BareMetalInfrastructure/preview/2024-08-01-preview/examples/AzureBareMetalStorageInstances_PatchTags_Delete.json if __name__ == "__main__": main() diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/conftest.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/conftest.py new file mode 100644 index 000000000000..42d428cb0344 --- /dev/null +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/conftest.py @@ -0,0 +1,43 @@ +# 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): + baremetalinfrastructure_subscription_id = os.environ.get( + "AZURE_SUBSCRIPTION_ID", "00000000-0000-0000-0000-000000000000" + ) + baremetalinfrastructure_tenant_id = os.environ.get("AZURE_TENANT_ID", "00000000-0000-0000-0000-000000000000") + baremetalinfrastructure_client_id = os.environ.get("AZURE_CLIENT_ID", "00000000-0000-0000-0000-000000000000") + baremetalinfrastructure_client_secret = os.environ.get( + "AZURE_CLIENT_SECRET", "00000000-0000-0000-0000-000000000000" + ) + add_general_regex_sanitizer( + regex=baremetalinfrastructure_subscription_id, value="00000000-0000-0000-0000-000000000000" + ) + add_general_regex_sanitizer(regex=baremetalinfrastructure_tenant_id, value="00000000-0000-0000-0000-000000000000") + add_general_regex_sanitizer(regex=baremetalinfrastructure_client_id, value="00000000-0000-0000-0000-000000000000") + add_general_regex_sanitizer( + regex=baremetalinfrastructure_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/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_azure_bare_metal_instances_operations.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_azure_bare_metal_instances_operations.py new file mode 100644 index 000000000000..8fb58b9e6f09 --- /dev/null +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_azure_bare_metal_instances_operations.py @@ -0,0 +1,150 @@ +# 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.baremetalinfrastructure import BareMetalInfrastructureClient + +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 TestBareMetalInfrastructureAzureBareMetalInstancesOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(BareMetalInfrastructureClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_azure_bare_metal_instances_begin_start(self, resource_group): + response = self.client.azure_bare_metal_instances.begin_start( + resource_group_name=resource_group.name, + azure_bare_metal_instance_name="str", + api_version="2024-08-01-preview", + ).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_azure_bare_metal_instances_begin_restart(self, resource_group): + response = self.client.azure_bare_metal_instances.begin_restart( + resource_group_name=resource_group.name, + azure_bare_metal_instance_name="str", + api_version="2024-08-01-preview", + ).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_azure_bare_metal_instances_begin_shutdown(self, resource_group): + response = self.client.azure_bare_metal_instances.begin_shutdown( + resource_group_name=resource_group.name, + azure_bare_metal_instance_name="str", + api_version="2024-08-01-preview", + ).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_azure_bare_metal_instances_list_by_subscription(self, resource_group): + response = self.client.azure_bare_metal_instances.list_by_subscription( + api_version="2024-08-01-preview", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_azure_bare_metal_instances_list_by_resource_group(self, resource_group): + response = self.client.azure_bare_metal_instances.list_by_resource_group( + resource_group_name=resource_group.name, + api_version="2024-08-01-preview", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_azure_bare_metal_instances_get(self, resource_group): + response = self.client.azure_bare_metal_instances.get( + resource_group_name=resource_group.name, + azure_bare_metal_instance_name="str", + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_azure_bare_metal_instances_create(self, resource_group): + response = self.client.azure_bare_metal_instances.create( + resource_group_name=resource_group.name, + azure_bare_metal_instance_name="str", + request_body_parameters={ + "location": "str", + "azureBareMetalInstanceId": "str", + "hardwareProfile": {"azureBareMetalInstanceSize": "str", "hardwareType": "str"}, + "hwRevision": "str", + "id": "str", + "name": "str", + "networkProfile": {"circuitId": "str", "networkInterfaces": [{"ipAddress": "str"}]}, + "osProfile": {"computerName": "str", "osType": "str", "sshPublicKey": "str", "version": "str"}, + "partnerNodeId": "str", + "powerState": "str", + "provisioningState": "str", + "proximityPlacementGroup": "str", + "storageProfile": {"nfsIpAddress": "str", "osDisks": [{"diskSizeGB": 0, "lun": 0, "name": "str"}]}, + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "tags": {"str": "str"}, + "type": "str", + }, + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_azure_bare_metal_instances_update(self, resource_group): + response = self.client.azure_bare_metal_instances.update( + resource_group_name=resource_group.name, + azure_bare_metal_instance_name="str", + tags_parameter={"tags": {"str": "str"}}, + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_azure_bare_metal_instances_delete(self, resource_group): + response = self.client.azure_bare_metal_instances.delete( + resource_group_name=resource_group.name, + azure_bare_metal_instance_name="str", + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_azure_bare_metal_instances_operations_async.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_azure_bare_metal_instances_operations_async.py new file mode 100644 index 000000000000..ba4893ab629f --- /dev/null +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_azure_bare_metal_instances_operations_async.py @@ -0,0 +1,157 @@ +# 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.baremetalinfrastructure.aio import BareMetalInfrastructureClient + +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 TestBareMetalInfrastructureAzureBareMetalInstancesOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(BareMetalInfrastructureClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_azure_bare_metal_instances_begin_start(self, resource_group): + response = await ( + await self.client.azure_bare_metal_instances.begin_start( + resource_group_name=resource_group.name, + azure_bare_metal_instance_name="str", + api_version="2024-08-01-preview", + ) + ).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_azure_bare_metal_instances_begin_restart(self, resource_group): + response = await ( + await self.client.azure_bare_metal_instances.begin_restart( + resource_group_name=resource_group.name, + azure_bare_metal_instance_name="str", + api_version="2024-08-01-preview", + ) + ).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_azure_bare_metal_instances_begin_shutdown(self, resource_group): + response = await ( + await self.client.azure_bare_metal_instances.begin_shutdown( + resource_group_name=resource_group.name, + azure_bare_metal_instance_name="str", + api_version="2024-08-01-preview", + ) + ).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_azure_bare_metal_instances_list_by_subscription(self, resource_group): + response = self.client.azure_bare_metal_instances.list_by_subscription( + api_version="2024-08-01-preview", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_azure_bare_metal_instances_list_by_resource_group(self, resource_group): + response = self.client.azure_bare_metal_instances.list_by_resource_group( + resource_group_name=resource_group.name, + api_version="2024-08-01-preview", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_azure_bare_metal_instances_get(self, resource_group): + response = await self.client.azure_bare_metal_instances.get( + resource_group_name=resource_group.name, + azure_bare_metal_instance_name="str", + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_azure_bare_metal_instances_create(self, resource_group): + response = await self.client.azure_bare_metal_instances.create( + resource_group_name=resource_group.name, + azure_bare_metal_instance_name="str", + request_body_parameters={ + "location": "str", + "azureBareMetalInstanceId": "str", + "hardwareProfile": {"azureBareMetalInstanceSize": "str", "hardwareType": "str"}, + "hwRevision": "str", + "id": "str", + "name": "str", + "networkProfile": {"circuitId": "str", "networkInterfaces": [{"ipAddress": "str"}]}, + "osProfile": {"computerName": "str", "osType": "str", "sshPublicKey": "str", "version": "str"}, + "partnerNodeId": "str", + "powerState": "str", + "provisioningState": "str", + "proximityPlacementGroup": "str", + "storageProfile": {"nfsIpAddress": "str", "osDisks": [{"diskSizeGB": 0, "lun": 0, "name": "str"}]}, + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "tags": {"str": "str"}, + "type": "str", + }, + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_azure_bare_metal_instances_update(self, resource_group): + response = await self.client.azure_bare_metal_instances.update( + resource_group_name=resource_group.name, + azure_bare_metal_instance_name="str", + tags_parameter={"tags": {"str": "str"}}, + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_azure_bare_metal_instances_delete(self, resource_group): + response = await self.client.azure_bare_metal_instances.delete( + resource_group_name=resource_group.name, + azure_bare_metal_instance_name="str", + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_azure_bare_metal_storage_instances_operations.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_azure_bare_metal_storage_instances_operations.py new file mode 100644 index 000000000000..1e6d144738f1 --- /dev/null +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_azure_bare_metal_storage_instances_operations.py @@ -0,0 +1,118 @@ +# 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.baremetalinfrastructure import BareMetalInfrastructureClient + +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 TestBareMetalInfrastructureAzureBareMetalStorageInstancesOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(BareMetalInfrastructureClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_azure_bare_metal_storage_instances_list_by_subscription(self, resource_group): + response = self.client.azure_bare_metal_storage_instances.list_by_subscription( + api_version="2024-08-01-preview", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_azure_bare_metal_storage_instances_list_by_resource_group(self, resource_group): + response = self.client.azure_bare_metal_storage_instances.list_by_resource_group( + resource_group_name=resource_group.name, + api_version="2024-08-01-preview", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_azure_bare_metal_storage_instances_get(self, resource_group): + response = self.client.azure_bare_metal_storage_instances.get( + resource_group_name=resource_group.name, + azure_bare_metal_storage_instance_name="str", + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_azure_bare_metal_storage_instances_create(self, resource_group): + response = self.client.azure_bare_metal_storage_instances.create( + resource_group_name=resource_group.name, + azure_bare_metal_storage_instance_name="str", + request_body_parameters={ + "location": "str", + "azureBareMetalStorageInstanceUniqueIdentifier": "str", + "id": "str", + "identity": {"principalId": "str", "tenantId": "str", "type": "str"}, + "name": "str", + "storageProperties": { + "generation": "str", + "hardwareType": "str", + "offeringType": "str", + "provisioningState": "str", + "storageBillingProperties": {"azureBareMetalStorageInstanceSize": "str", "billingMode": "str"}, + "storageType": "str", + "workloadType": "str", + }, + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "tags": {"str": "str"}, + "type": "str", + }, + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_azure_bare_metal_storage_instances_update(self, resource_group): + response = self.client.azure_bare_metal_storage_instances.update( + resource_group_name=resource_group.name, + azure_bare_metal_storage_instance_name="str", + azure_bare_metal_storage_instance_body_parameter={ + "identity": {"principalId": "str", "tenantId": "str", "type": "str"}, + "tags": {"str": "str"}, + }, + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_azure_bare_metal_storage_instances_delete(self, resource_group): + response = self.client.azure_bare_metal_storage_instances.delete( + resource_group_name=resource_group.name, + azure_bare_metal_storage_instance_name="str", + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_azure_bare_metal_storage_instances_operations_async.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_azure_bare_metal_storage_instances_operations_async.py new file mode 100644 index 000000000000..6ef1c997ff30 --- /dev/null +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_azure_bare_metal_storage_instances_operations_async.py @@ -0,0 +1,119 @@ +# 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.baremetalinfrastructure.aio import BareMetalInfrastructureClient + +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 TestBareMetalInfrastructureAzureBareMetalStorageInstancesOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(BareMetalInfrastructureClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_azure_bare_metal_storage_instances_list_by_subscription(self, resource_group): + response = self.client.azure_bare_metal_storage_instances.list_by_subscription( + api_version="2024-08-01-preview", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_azure_bare_metal_storage_instances_list_by_resource_group(self, resource_group): + response = self.client.azure_bare_metal_storage_instances.list_by_resource_group( + resource_group_name=resource_group.name, + api_version="2024-08-01-preview", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_azure_bare_metal_storage_instances_get(self, resource_group): + response = await self.client.azure_bare_metal_storage_instances.get( + resource_group_name=resource_group.name, + azure_bare_metal_storage_instance_name="str", + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_azure_bare_metal_storage_instances_create(self, resource_group): + response = await self.client.azure_bare_metal_storage_instances.create( + resource_group_name=resource_group.name, + azure_bare_metal_storage_instance_name="str", + request_body_parameters={ + "location": "str", + "azureBareMetalStorageInstanceUniqueIdentifier": "str", + "id": "str", + "identity": {"principalId": "str", "tenantId": "str", "type": "str"}, + "name": "str", + "storageProperties": { + "generation": "str", + "hardwareType": "str", + "offeringType": "str", + "provisioningState": "str", + "storageBillingProperties": {"azureBareMetalStorageInstanceSize": "str", "billingMode": "str"}, + "storageType": "str", + "workloadType": "str", + }, + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "tags": {"str": "str"}, + "type": "str", + }, + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_azure_bare_metal_storage_instances_update(self, resource_group): + response = await self.client.azure_bare_metal_storage_instances.update( + resource_group_name=resource_group.name, + azure_bare_metal_storage_instance_name="str", + azure_bare_metal_storage_instance_body_parameter={ + "identity": {"principalId": "str", "tenantId": "str", "type": "str"}, + "tags": {"str": "str"}, + }, + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_azure_bare_metal_storage_instances_delete(self, resource_group): + response = await self.client.azure_bare_metal_storage_instances.delete( + resource_group_name=resource_group.name, + azure_bare_metal_storage_instance_name="str", + api_version="2024-08-01-preview", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_operations.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_operations.py new file mode 100644 index 000000000000..ebca534bb40c --- /dev/null +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_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.baremetalinfrastructure import BareMetalInfrastructureClient + +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 TestBareMetalInfrastructureOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(BareMetalInfrastructureClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_operations_list(self, resource_group): + response = self.client.operations.list( + api_version="2024-08-01-preview", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_operations_async.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_operations_async.py new file mode 100644 index 000000000000..e1cc4de9ca0c --- /dev/null +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/generated_tests/test_bare_metal_infrastructure_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.baremetalinfrastructure.aio import BareMetalInfrastructureClient + +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 TestBareMetalInfrastructureOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(BareMetalInfrastructureClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_operations_list(self, resource_group): + response = self.client.operations.list( + api_version="2024-08-01-preview", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/setup.py b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/setup.py index 998aba60aff4..97401fa4d960 100644 --- a/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/setup.py +++ b/sdk/baremetalinfrastructure/azure-mgmt-baremetalinfrastructure/setup.py @@ -53,11 +53,10 @@ "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", + "Programming Language :: Python :: 3.12", "License :: OSI Approved :: MIT License", ], zip_safe=False, @@ -74,10 +73,10 @@ "pytyped": ["py.typed"], }, install_requires=[ - "isodate<1.0.0,>=0.6.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.5.0", ], - python_requires=">=3.7", + python_requires=">=3.9", )