diff --git a/sdk/peering/azure-mgmt-peering/CHANGELOG.md b/sdk/peering/azure-mgmt-peering/CHANGELOG.md index 9dbeea242eb2..cb0a24229840 100644 --- a/sdk/peering/azure-mgmt-peering/CHANGELOG.md +++ b/sdk/peering/azure-mgmt-peering/CHANGELOG.md @@ -1,5 +1,145 @@ # Release History +## 2.0.0 (2025-05-12) + +### Features Added + + - Client `PeeringManagementClient` added operation group `cdn_peering_prefixes` + - Client `PeeringManagementClient` added operation group `looking_glass` + - Client `PeeringManagementClient` added operation group `registered_asns` + - Client `PeeringManagementClient` added operation group `registered_prefixes` + - Client `PeeringManagementClient` added operation group `received_routes` + - Client `PeeringManagementClient` added operation group `connection_monitor_tests` + - Client `PeeringManagementClient` added operation group `peering_service_countries` + - Client `PeeringManagementClient` added operation group `rp_unbilled_prefixes` + - Enum `ConnectionState` added member `EXTERNAL_BLOCKER` + - Enum `ConnectionState` added member `TYPE_CHANGE_IN_PROGRESS` + - Enum `ConnectionState` added member `TYPE_CHANGE_REQUESTED` + - Model `DirectConnection` added property `microsoft_tracking_id` + - Model `DirectConnection` added property `migration_work_window_bgp_session_same_device` + - Model `DirectConnection` added property `last_failure_time_utc` + - Model `DirectConnection` added property `error_message` + - Model `DirectConnection` added property `previous_connection_provisioning_state` + - Model `DirectConnection` added property `migration_work_window_tracker` + - Enum `DirectPeeringType` added member `EDGE_ZONE_FOR_OPERATORS` + - Enum `DirectPeeringType` added member `IX` + - Enum `DirectPeeringType` added member `IX_RS` + - Enum `DirectPeeringType` added member `PEER_PROP` + - Enum `DirectPeeringType` added member `VOICE` + - Enum `Enum0` added member `UNAVAILABLE` + - Model `ErrorResponse` added property `error` + - Model `ExchangeConnection` added property `migration_work_window_bgp_session_same_device` + - Model `ExchangeConnection` added property `last_failure_time_utc` + - Model `ExchangeConnection` added property `error_message` + - Model `ExchangeConnection` added property `previous_connection_provisioning_state` + - Model `ExchangeConnection` added property `migration_work_window_tracker` + - Enum `LearnedType` added member `VIA_SERVICE_PROVIDER` + - Model `Operation` added property `service_specification` + - Model `PeerAsn` added property `peer_contact_detail` + - Model `PeerAsn` added property `error_message` + - Model `Peering` added property `connectivity_probes` + - Model `PeeringService` added property `sku` + - Model `PeeringService` added property `provider_primary_peering_location` + - Model `PeeringService` added property `provider_backup_peering_location` + - Model `PeeringService` added property `log_analytics_workspace_properties` + - Model `PeeringServicePrefix` added property `error_message` + - Model `PeeringServicePrefix` added property `events` + - Model `PeeringServicePrefix` added property `peering_service_prefix_key` + - Model `PeeringServiceProvider` added property `peering_locations` + - Enum `PrefixValidationState` added member `WARNING` + - Added model `CdnPeeringPrefix` + - Added model `CdnPeeringPrefixListResult` + - Added enum `Command` + - Added model `ConnectionMonitorTest` + - Added model `ConnectionMonitorTestListResult` + - Added model `ConnectivityProbe` + - Added model `ContactDetail` + - Added enum `Enum11` + - Added enum `Enum13` + - Added model `ErrorDetail` + - Added enum `LegacyPeeringsKind` + - Added model `LogAnalyticsWorkspaceProperties` + - Added enum `LookingGlassCommand` + - Added model `LookingGlassOutput` + - Added enum `LookingGlassSourceType` + - Added model `MetricDimension` + - Added model `MetricSpecification` + - Added enum `PeeringLocationsDirectPeeringType` + - Added enum `PeeringLocationsKind` + - Added model `PeeringReceivedRoute` + - Added model `PeeringReceivedRouteListResult` + - Added model `PeeringRegisteredAsn` + - Added model `PeeringRegisteredAsnListResult` + - Added model `PeeringRegisteredPrefix` + - Added model `PeeringRegisteredPrefixListResult` + - Added model `PeeringServiceCountry` + - Added model `PeeringServiceCountryListResult` + - Added model `PeeringServicePrefixEvent` + - Added model `PeeringServiceSku` + - Added enum `PreviousConnectionProvisioningState` + - Added enum `Protocol` + - Added enum `Role` + - Added model `RpUnbilledPrefix` + - Added model `RpUnbilledPrefixListResult` + - Added model `ServiceSpecification` + - Model `LegacyPeeringsOperations` added parameter `kwargs` in method `__init__` + - Model `Operations` added parameter `kwargs` in method `__init__` + - Model `PeerAsnsOperations` added parameter `kwargs` in method `__init__` + - Model `PeeringLocationsOperations` added parameter `kwargs` in method `__init__` + - Model `PeeringServiceLocationsOperations` added parameter `kwargs` in method `__init__` + - Model `PeeringServiceProvidersOperations` added parameter `kwargs` in method `__init__` + - Model `PeeringServicesOperations` added parameter `kwargs` in method `__init__` + - Model `PeeringServicesOperations` added method `initialize_connection_monitor` + - Model `PeeringsOperations` added parameter `kwargs` in method `__init__` + - Model `PrefixesOperations` added parameter `kwargs` in method `__init__` + - Model `PrefixesOperations` added method `create_or_update` + - Model `PrefixesOperations` added method `delete` + - Added model `CdnPeeringPrefixesOperations` + - Added model `ConnectionMonitorTestsOperations` + - Added model `LookingGlassOperations` + - Added model `PeeringServiceCountriesOperations` + - Added model `ReceivedRoutesOperations` + - Added model `RegisteredAsnsOperations` + - Added model `RegisteredPrefixesOperations` + - Added model `RpUnbilledPrefixesOperations` + - Method `PeeringManagementClient.check_service_provider_availability` has a new overload `def check_service_provider_availability(self: None, check_service_provider_availability_input: CheckServiceProviderAvailabilityInput, content_type: str)` + - Method `PeeringManagementClient.check_service_provider_availability` has a new overload `def check_service_provider_availability(self: None, check_service_provider_availability_input: IO[bytes], content_type: str)` + - Method `PeerAsnsOperations.create_or_update` has a new overload `def create_or_update(self: None, peer_asn_name: str, peer_asn: PeerAsn, content_type: str)` + - Method `PeerAsnsOperations.create_or_update` has a new overload `def create_or_update(self: None, peer_asn_name: str, peer_asn: IO[bytes], content_type: str)` + - Method `PeeringManagementClientOperationsMixin.check_service_provider_availability` has a new overload `def check_service_provider_availability(self: None, check_service_provider_availability_input: CheckServiceProviderAvailabilityInput, content_type: str)` + - Method `PeeringManagementClientOperationsMixin.check_service_provider_availability` has a new overload `def check_service_provider_availability(self: None, check_service_provider_availability_input: IO[bytes], content_type: str)` + - Method `PeeringServicesOperations.create_or_update` has a new overload `def create_or_update(self: None, resource_group_name: str, peering_service_name: str, peering_service: PeeringService, content_type: str)` + - Method `PeeringServicesOperations.create_or_update` has a new overload `def create_or_update(self: None, resource_group_name: str, peering_service_name: str, peering_service: IO[bytes], content_type: str)` + - Method `PeeringServicesOperations.update` has a new overload `def update(self: None, resource_group_name: str, peering_service_name: str, tags: ResourceTags, content_type: str)` + - Method `PeeringServicesOperations.update` has a new overload `def update(self: None, resource_group_name: str, peering_service_name: str, tags: IO[bytes], content_type: str)` + - Method `PeeringsOperations.create_or_update` has a new overload `def create_or_update(self: None, resource_group_name: str, peering_name: str, peering: Peering, content_type: str)` + - Method `PeeringsOperations.create_or_update` has a new overload `def create_or_update(self: None, resource_group_name: str, peering_name: str, peering: IO[bytes], content_type: str)` + - Method `PeeringsOperations.update` has a new overload `def update(self: None, resource_group_name: str, peering_name: str, tags: ResourceTags, content_type: str)` + - Method `PeeringsOperations.update` has a new overload `def update(self: None, resource_group_name: str, peering_name: str, tags: IO[bytes], content_type: str)` + - Method `PrefixesOperations.create_or_update` has a new overload `def create_or_update(self: None, resource_group_name: str, peering_service_name: str, prefix_name: str, peering_service_prefix: PeeringServicePrefix, content_type: str)` + - Method `PrefixesOperations.create_or_update` has a new overload `def create_or_update(self: None, resource_group_name: str, peering_service_name: str, prefix_name: str, peering_service_prefix: IO[bytes], content_type: str)` + - Method `ConnectionMonitorTestsOperations.create_or_update` has a new overload `def create_or_update(self: None, resource_group_name: str, peering_service_name: str, connection_monitor_test_name: str, connection_monitor_test: ConnectionMonitorTest, content_type: str)` + - Method `ConnectionMonitorTestsOperations.create_or_update` has a new overload `def create_or_update(self: None, resource_group_name: str, peering_service_name: str, connection_monitor_test_name: str, connection_monitor_test: IO[bytes], content_type: str)` + - Method `RegisteredAsnsOperations.create_or_update` has a new overload `def create_or_update(self: None, resource_group_name: str, peering_name: str, registered_asn_name: str, registered_asn: PeeringRegisteredAsn, content_type: str)` + - Method `RegisteredAsnsOperations.create_or_update` has a new overload `def create_or_update(self: None, resource_group_name: str, peering_name: str, registered_asn_name: str, registered_asn: IO[bytes], content_type: str)` + - Method `RegisteredPrefixesOperations.create_or_update` has a new overload `def create_or_update(self: None, resource_group_name: str, peering_name: str, registered_prefix_name: str, registered_prefix: PeeringRegisteredPrefix, content_type: str)` + - Method `RegisteredPrefixesOperations.create_or_update` has a new overload `def create_or_update(self: None, resource_group_name: str, peering_name: str, registered_prefix_name: str, registered_prefix: IO[bytes], content_type: str)` + +### Breaking Changes + + - Deleted or renamed client operation group `PeeringManagementClient.peering_service_prefixes` + - Deleted or renamed enum value `Enum0.UN_AVAILABLE` + - Model `ErrorResponse` deleted or renamed its instance variable `code` + - Model `ErrorResponse` deleted or renamed its instance variable `message` + - Deleted or renamed enum value `LearnedType.VIA_PARTNER` + - Model `PeerAsn` deleted or renamed its instance variable `peer_contact_info` + - Deleted or renamed model `ContactInfo` + - Deleted or renamed model `Enum1` + - Deleted or renamed model `Enum14` + - Deleted or renamed model `Enum15` + - Deleted or renamed model `Name` + - Deleted or renamed model `PeeringServicePrefixesOperations` + ## 2.0.0b1 (2022-11-01) ### Features Added diff --git a/sdk/peering/azure-mgmt-peering/README.md b/sdk/peering/azure-mgmt-peering/README.md index a394d49932f4..919e81eb2927 100644 --- a/sdk/peering/azure-mgmt-peering/README.md +++ b/sdk/peering/azure-mgmt-peering/README.md @@ -1,28 +1,61 @@ # Microsoft Azure SDK for Python This is the Microsoft Azure Peering 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_ _Azure SDK Python packages support for Python 2.7 has ended 01 January 2022. For more information and questions, please refer to https://github.com/Azure/azure-sdk-for-python/issues/20691_ -# Usage +## Getting started +### Prerequisites -To learn how to use this package, see the [quickstart guide](https://aka.ms/azsdk/python/mgmt) - -For docs and references, see [Python SDK References](https://docs.microsoft.com/python/api/overview/azure/) -Code samples for this package can be found at [Peering Management](https://docs.microsoft.com/samples/browse/?languages=python&term=Getting%20started%20-%20Managing&terms=Getting%20started%20-%20Managing) on docs.microsoft.com. -Additional code samples for different Azure services are available at [Samples Repo](https://aka.ms/azsdk/python/mgmt/samples) +- Python 3.9+ is required to use this package. +- [Azure subscription](https://azure.microsoft.com/free/) +### Install the package -# Provide Feedback +```bash +pip install azure-mgmt-peering +pip install azure-identity +``` -If you encounter any bugs or have suggestions, please file an issue in the -[Issues](https://github.com/Azure/azure-sdk-for-python/issues) -section of the project. +### Authentication + +By default, [Azure Active Directory](https://aka.ms/awps/aad) token authentication depends on correct configuration of the following environment variables. + +- `AZURE_CLIENT_ID` for Azure client ID. +- `AZURE_TENANT_ID` for Azure tenant ID. +- `AZURE_CLIENT_SECRET` for Azure client secret. + +In addition, Azure subscription ID can be configured via environment variable `AZURE_SUBSCRIPTION_ID`. + +With above configuration, client can be authenticated by following code: + +```python +from azure.identity import DefaultAzureCredential +from azure.mgmt.peering import PeeringManagementClient +import os +sub_id = os.getenv("AZURE_SUBSCRIPTION_ID") +client = PeeringManagementClient(credential=DefaultAzureCredential(), subscription_id=sub_id) +``` +## Examples +Code samples for this package can be found at: +- [Search Peering Management](https://docs.microsoft.com/samples/browse/?languages=python&term=Getting%20started%20-%20Managing&terms=Getting%20started%20-%20Managing) on docs.microsoft.com +- [Azure Python Mgmt SDK Samples Repo](https://aka.ms/azsdk/python/mgmt/samples) + + +## Troubleshooting + +## Next steps + +## Provide Feedback + +If you encounter any bugs or have suggestions, please file an issue in the +[Issues](https://github.com/Azure/azure-sdk-for-python/issues) +section of the project. diff --git a/sdk/peering/azure-mgmt-peering/_meta.json b/sdk/peering/azure-mgmt-peering/_meta.json index fa07f7d48439..322fbd88c4d3 100644 --- a/sdk/peering/azure-mgmt-peering/_meta.json +++ b/sdk/peering/azure-mgmt-peering/_meta.json @@ -1,11 +1,11 @@ { - "commit": "4522e1d3fb6dcb81bc63e3414d11dd7eaf08264b", + "commit": "2271c26de5b7855e1621e7d5d7dc0b6678d3b4a2", "repository_url": "https://github.com/Azure/azure-rest-api-specs", - "autorest": "3.9.2", + "autorest": "3.10.2", "use": [ - "@autorest/python@6.2.1", - "@autorest/modelerfour@4.24.3" + "@autorest/python@6.34.1", + "@autorest/modelerfour@4.27.0" ], - "autorest_command": "autorest specification/peering/resource-manager/readme.md --generate-sample=True --include-x-ms-examples-original-file=True --python --python-sdks-folder=/home/vsts/work/1/azure-sdk-for-python/sdk --use=@autorest/python@6.2.1 --use=@autorest/modelerfour@4.24.3 --version=3.9.2 --version-tolerant=False", + "autorest_command": "autorest specification/peering/resource-manager/readme.md --generate-sample=True --generate-test=True --include-x-ms-examples-original-file=True --python --python-sdks-folder=/mnt/vss/_work/1/s/azure-sdk-for-python/sdk --use=@autorest/python@6.34.1 --use=@autorest/modelerfour@4.27.0 --version=3.10.2 --version-tolerant=False", "readme": "specification/peering/resource-manager/readme.md" } \ No newline at end of file diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/__init__.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/__init__.py index c42f38961cb4..0c29818eb636 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/__init__.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/__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 ._peering_management_client import PeeringManagementClient +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._peering_management_client import PeeringManagementClient # type: ignore from ._version import VERSION __version__ = VERSION try: from ._patch import __all__ as _patch_all - from ._patch import * # type: ignore # 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__ = [ "PeeringManagementClient", ] -__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/peering/azure-mgmt-peering/azure/mgmt/peering/_configuration.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_configuration.py index 4b04cccd6972..702fb232a880 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_configuration.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_configuration.py @@ -6,26 +6,18 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys 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 sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports - if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials import TokenCredential -class PeeringManagementClientConfiguration(Configuration): # pylint: disable=too-many-instance-attributes +class PeeringManagementClientConfiguration: # pylint: disable=too-many-instance-attributes """Configuration for PeeringManagementClient. Note that all parameters used to create this instance are saved as instance @@ -35,14 +27,13 @@ class PeeringManagementClientConfiguration(Configuration): # pylint: disable=to :type credential: ~azure.core.credentials.TokenCredential :param subscription_id: The Azure subscription ID. Required. :type subscription_id: str - :keyword api_version: Api Version. Default value is "2022-10-01". Note that overriding this + :keyword api_version: Api Version. Default value is "2025-05-01". 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(PeeringManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop("api_version", "2022-10-01") # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", "2025-05-01") if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -54,20 +45,18 @@ 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-peering/{}".format(VERSION)) + self.polling_interval = kwargs.get("polling_interval", 30) self._configure(**kwargs) - def _configure( - self, **kwargs # type: Any - ): - # type: (...) -> None + def _configure(self, **kwargs: Any) -> None: self.user_agent_policy = kwargs.get("user_agent_policy") or policies.UserAgentPolicy(**kwargs) self.headers_policy = kwargs.get("headers_policy") or policies.HeadersPolicy(**kwargs) self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs) self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs) self.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**kwargs) - self.retry_policy = kwargs.get("retry_policy") or policies.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/peering/azure-mgmt-peering/azure/mgmt/peering/_peering_management_client.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_peering_management_client.py index 6cbb27568b6f..e7e0b9a108e7 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_peering_management_client.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_peering_management_client.py @@ -7,14 +7,19 @@ # -------------------------------------------------------------------------- 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 +from . import models as _models from ._configuration import PeeringManagementClientConfiguration -from ._serialization import Deserializer, Serializer +from ._utils.serialization import Deserializer, Serializer from .operations import ( CdnPeeringPrefixesOperations, ConnectionMonitorTestsOperations, @@ -37,13 +42,10 @@ ) if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials import TokenCredential -class PeeringManagementClient( - PeeringManagementClientOperationsMixin -): # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes +class PeeringManagementClient(PeeringManagementClientOperationsMixin): # pylint: disable=too-many-instance-attributes """Peering Client. :ivar cdn_peering_prefixes: CdnPeeringPrefixesOperations operations @@ -88,26 +90,46 @@ class PeeringManagementClient( :type credential: ~azure.core.credentials.TokenCredential :param subscription_id: The Azure subscription ID. 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 "2022-10-01". Note that overriding this + :keyword api_version: Api Version. Default value is "2025-05-01". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ def __init__( - self, - credential: "TokenCredential", - subscription_id: str, - base_url: str = "https://management.azure.com", - **kwargs: Any + 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 = PeeringManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs + credential=credential, subscription_id=subscription_id, credential_scopes=credential_scopes, **kwargs ) - self._client = ARMPipelineClient(base_url=base_url, config=self._config, **kwargs) - client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} + _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) self._deserialize = Deserializer(client_models) self._serialize.client_side_validation = False @@ -147,7 +169,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 @@ -167,17 +189,14 @@ def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: request_copy = deepcopy(request) request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, **kwargs) + return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore - def close(self): - # type: () -> None + def close(self) -> None: self._client.close() - def __enter__(self): - # type: () -> PeeringManagementClient + def __enter__(self) -> Self: self._client.__enter__() return self - def __exit__(self, *exc_details): - # type: (Any) -> None + def __exit__(self, *exc_details: Any) -> None: self._client.__exit__(*exc_details) diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_utils/__init__.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_utils/__init__.py new file mode 100644 index 000000000000..0af9b28f6607 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_utils/__init__.py @@ -0,0 +1,6 @@ +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_serialization.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_utils/serialization.py similarity index 74% rename from sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_serialization.py rename to sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_utils/serialization.py index 7c1dedb5133d..f5187701d7be 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_serialization.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_utils/serialization.py @@ -1,30 +1,13 @@ +# 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 import calendar @@ -37,23 +20,35 @@ import re import sys import codecs +from typing import ( + Dict, + Any, + cast, + Optional, + Union, + AnyStr, + IO, + Mapping, + Callable, + MutableMapping, + List, +) try: from urllib import quote # type: ignore except ImportError: - from urllib.parse import quote # type: ignore + from urllib.parse import quote import xml.etree.ElementTree as ET -import isodate +import isodate # type: ignore +from typing_extensions import Self -from typing import Dict, Any, cast, TYPE_CHECKING - -from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback +from azure.core.exceptions import DeserializationError, SerializationError +from azure.core.serialization import NULL as CoreNull _BOM = codecs.BOM_UTF8.decode(encoding="utf-8") -if TYPE_CHECKING: - from typing import Optional, Union, AnyStr, IO, Mapping +JSON = MutableMapping[str, Any] class RawDeserializer: @@ -65,8 +60,7 @@ class RawDeserializer: CONTEXT_NAME = "deserialized_data" @classmethod - def deserialize_from_text(cls, data, content_type=None): - # type: (Optional[Union[AnyStr, IO]], Optional[str]) -> Any + def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type: Optional[str] = None) -> Any: """Decode data according to content-type. Accept a stream of data as well, but will be load at once in memory for now. @@ -76,6 +70,8 @@ def deserialize_from_text(cls, data, content_type=None): :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 @@ -97,7 +93,7 @@ def deserialize_from_text(cls, data, content_type=None): 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: @@ -109,7 +105,7 @@ def deserialize_from_text(cls, data, content_type=None): 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 @@ -128,17 +124,23 @@ 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 - def deserialize_from_http_generics(cls, body_bytes, headers): - # type: (Optional[Union[AnyStr, IO]], Mapping) -> Any + def deserialize_from_http_generics(cls, body_bytes: Optional[Union[AnyStr, IO]], headers: Mapping) -> Any: """Deserialize from HTTP response. Use bytes and headers to NOT use any requests/aiohttp or whatever specific implementation. Headers will tested for "content-type" + + :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 @@ -156,13 +158,6 @@ def deserialize_from_http_generics(cls, body_bytes, headers): return None -try: - basestring # type: ignore - unicode_str = unicode # type: ignore -except NameError: - basestring = str # type: ignore - unicode_str = str # type: ignore - _LOGGER = logging.getLogger(__name__) try: @@ -170,80 +165,31 @@ def deserialize_from_http_generics(cls, body_bytes, headers): except NameError: _long_type = int - -class UTC(datetime.tzinfo): - """Time Zone info for handling UTC""" - - def utcoffset(self, dt): - """UTF offset for UTC is 0.""" - return datetime.timedelta(0) - - def tzname(self, dt): - """Timestamp representation.""" - return "Z" - - def dst(self, dt): - """No daylight saving for UTC.""" - return datetime.timedelta(hours=1) - - -try: - from datetime import timezone as _FixedOffset -except ImportError: # Python 2.7 - - class _FixedOffset(datetime.tzinfo): # type: ignore - """Fixed offset in minutes east from UTC. - Copy/pasted from Python doc - :param datetime.timedelta offset: offset in timedelta format - """ - - def __init__(self, offset): - self.__offset = offset - - def utcoffset(self, dt): - return self.__offset - - def tzname(self, dt): - return str(self.__offset.total_seconds() / 3600) - - def __repr__(self): - return "".format(self.tzname(None)) - - def dst(self, dt): - return datetime.timedelta(0) - - def __getinitargs__(self): - return (self.__offset,) - - -try: - from datetime import timezone - - TZ_UTC = timezone.utc # type: ignore -except ImportError: - TZ_UTC = UTC() # type: ignore +TZ_UTC = datetime.timezone.utc _FLATTEN = re.compile(r"(? None: + self.additional_properties: Optional[Dict[str, Any]] = {} + for k in kwargs: # pylint: disable=consider-using-dict-items if k not in self._attribute_map: _LOGGER.warning("%s is not a known attribute of class %s and will be ignored", k, self.__class__) elif k in self._validation and self._validation[k].get("readonly", False): @@ -290,43 +243,57 @@ def __init__(self, **kwargs): else: setattr(self, k, kwargs[k]) - def __eq__(self, other): - """Compare objects by comparing all attributes.""" + def __eq__(self, other: Any) -> bool: + """Compare objects by comparing all attributes. + + :param object other: The object to compare + :returns: True if objects are equal + :rtype: bool + """ if isinstance(other, self.__class__): return self.__dict__ == other.__dict__ return False - def __ne__(self, other): - """Compare objects by comparing all attributes.""" + def __ne__(self, other: Any) -> bool: + """Compare objects by comparing all attributes. + + :param object other: The object to compare + :returns: True if objects are not equal + :rtype: bool + """ return not self.__eq__(other) - def __str__(self): + def __str__(self) -> str: return str(self.__dict__) @classmethod - def enable_additional_properties_sending(cls): + def enable_additional_properties_sending(cls) -> None: cls._attribute_map["additional_properties"] = {"key": "", "type": "{object}"} @classmethod - def is_xml_model(cls): + def is_xml_model(cls) -> bool: try: - cls._xml_map + cls._xml_map # type: ignore except AttributeError: return False return True @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 + xml_map = cls._xml_map # type: ignore except AttributeError: xml_map = {} return _create_xml_node(xml_map.get("name", cls.__name__), xml_map.get("prefix", None), xml_map.get("ns", None)) - def serialize(self, keep_readonly=False, **kwargs): - """Return the JSON that would be sent to azure from this model. + def serialize(self, keep_readonly: bool = False, **kwargs: Any) -> JSON: + """Return the JSON that would be sent to server from this model. This is an alias to `as_dict(full_restapi_key_transformer, keep_readonly=False)`. @@ -337,10 +304,17 @@ def serialize(self, keep_readonly=False, **kwargs): :rtype: dict """ serializer = Serializer(self._infer_class_models()) - return serializer._serialize(self, keep_readonly=keep_readonly, **kwargs) + return serializer._serialize( # type: ignore # pylint: disable=protected-access + self, keep_readonly=keep_readonly, **kwargs + ) - def as_dict(self, keep_readonly=True, key_transformer=attribute_transformer, **kwargs): - """Return a dict that can be JSONify using json.dump. + def as_dict( + self, + keep_readonly: bool = True, + key_transformer: Callable[[str, Dict[str, Any], Any], Any] = attribute_transformer, + **kwargs: Any + ) -> JSON: + """Return a dict that can be serialized using json.dump. Advanced usage might optionally use a callback as parameter: @@ -366,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): @@ -381,25 +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, data, content_type=None): + 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, data, key_extractors=None, content_type=None): + def from_dict( + cls, + data: Any, + key_extractors: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None, + content_type: Optional[str] = None, + ) -> Self: """Parse a dict using given key extractor return a model. By default consider key @@ -407,13 +390,15 @@ def from_dict(cls, data, key_extractors=None, content_type=None): and last_rest_key_case_insensitive_extractor) :param dict data: A dict using RestAPI structure + :param function key_extractors: A key extractor function. :param str content_type: JSON by default, set application/xml if XML. :returns: An instance of this model - :raises: DeserializationError if something went wrong + :raises DeserializationError: if something went wrong + :rtype: Self """ deserializer = Deserializer(cls._infer_class_models()) - deserializer.key_extractors = ( - [ + deserializer.key_extractors = ( # type: ignore + [ # type: ignore attribute_key_case_insensitive_extractor, rest_key_case_insensitive_extractor, last_rest_key_case_insensitive_extractor, @@ -421,7 +406,7 @@ def from_dict(cls, data, key_extractors=None, content_type=None): if key_extractors is None else key_extractors ) - return deserializer(cls.__name__, data, content_type=content_type) + return deserializer(cls.__name__, data, content_type=content_type) # type: ignore @classmethod def _flatten_subtype(cls, key, objects): @@ -429,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: @@ -453,7 +442,7 @@ def _classify(cls, response, objects): return cls flatten_mapping_type = cls._flatten_subtype(subtype_key, objects) try: - return objects[flatten_mapping_type[subtype_value]] + return objects[flatten_mapping_type[subtype_value]] # type: ignore except KeyError: _LOGGER.warning( "Subtype value %s has no mapping, use base class %s.", @@ -482,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"} @@ -521,7 +512,7 @@ class Serializer(object): "multiple": lambda x, y: x % y != 0, } - def __init__(self, classes=None): + def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: self.serialize_type = { "iso-8601": Serializer.serialize_iso, "rfc-1123": Serializer.serialize_rfc, @@ -537,17 +528,20 @@ def __init__(self, classes=None): "[]": self.serialize_iter, "{}": self.serialize_dict, } - self.dependencies = dict(classes) if classes else {} + self.dependencies: Dict[str, type] = dict(classes) if classes else {} self.key_transformer = full_restapi_key_transformer self.client_side_validation = True - def _serialize(self, target_obj, data_type=None, **kwargs): + def _serialize( # pylint: disable=too-many-nested-blocks, too-many-branches, too-many-statements, too-many-locals + self, target_obj, data_type=None, **kwargs + ): """Serialize data into a string according to type. - :param target_obj: The data to be serialized. + :param object target_obj: The data to be serialized. :param str data_type: The type to be serialized from. :rtype: str, dict - :raises: SerializationError if serialization fails. + :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) @@ -573,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"] == "": @@ -605,62 +601,63 @@ def _serialize(self, target_obj, data_type=None, **kwargs): if xml_desc.get("attr", False): if xml_ns: ET.register_namespace(xml_prefix, xml_ns) - xml_name = "{}{}".format(xml_ns, xml_name) - serialized.set(xml_name, new_attr) + xml_name = "{{{}}}{}".format(xml_ns, xml_name) + serialized.set(xml_name, new_attr) # type: ignore continue if xml_desc.get("text", False): - serialized.text = new_attr + serialized.text = new_attr # type: ignore continue if isinstance(new_attr, list): - serialized.extend(new_attr) + 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 new_attr.tag = "}".join([splitted_tag[0], xml_name]) else: new_attr.tag = xml_name - serialized.append(new_attr) + serialized.append(new_attr) # type: ignore else: # That's a basic type # Integrate namespace if necessary local_node = _create_xml_node(xml_name, xml_prefix, xml_ns) - local_node.text = unicode_str(new_attr) - serialized.append(local_node) + local_node.text = str(new_attr) + serialized.append(local_node) # type: ignore else: # JSON - for k in reversed(keys): - unflattened = {k: new_attr} - new_attr = unflattened + for k in reversed(keys): # type: ignore + new_attr = {k: new_attr} _new_attr = new_attr _serialized = serialized - for k in keys: + for k in keys: # type: ignore if k not in _serialized: - _serialized.update(_new_attr) - _new_attr = _new_attr[k] + _serialized.update(_new_attr) # type: ignore + _new_attr = _new_attr[k] # type: ignore _serialized = _serialized[k] - except ValueError: - continue + except ValueError as err: + if isinstance(err, SerializationError): + raise except (AttributeError, KeyError, TypeError) as err: msg = "Attribute {} in object {} cannot be serialized.\n{}".format(attr_name, class_name, str(target_obj)) - raise_with_traceback(SerializationError, msg, err) - else: - return serialized + raise SerializationError(msg) from err + return serialized def body(self, data, data_type, **kwargs): """Serialize data intended for a request body. - :param data: The data to be serialized. + :param object data: The data to be serialized. :param str data_type: The type to be serialized from. :rtype: dict - :raises: SerializationError if serialization fails. - :raises: ValueError if data is None + :raises SerializationError: if serialization fails. + :raises ValueError: if data is None + :returns: The serialized request body """ # Just in case this is a dict - internal_data_type = data_type.strip("[]{}") - internal_data_type = self.dependencies.get(internal_data_type, None) + internal_data_type_str = data_type.strip("[]{}") + internal_data_type = self.dependencies.get(internal_data_type_str, None) try: is_xml_model_serialization = kwargs["is_xml"] except KeyError: @@ -675,7 +672,7 @@ def body(self, data, data_type, **kwargs): # We're not able to deal with additional properties for now. deserializer.additional_properties_detection = False if is_xml_model_serialization: - deserializer.key_extractors = [ + deserializer.key_extractors = [ # type: ignore attribute_key_case_insensitive_extractor, ] else: @@ -684,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) @@ -706,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. - :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] - data = [self.serialize_data(d, internal_data_type, **kwargs) if d is not None else "" for d in data] - if not kwargs.get("skip_quote", False): - data = [quote(str(d), safe="") for d in data] - return str(self.serialize_iter(data, internal_data_type, **kwargs)) + do_quote = not kwargs.get("skip_quote", False) + return self.serialize_iter(data, internal_data_type, do_quote=do_quote, **kwargs) # Not a list, regular serialization output = self.serialize_data(data, data_type, **kwargs) @@ -739,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]"]: @@ -760,30 +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 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 @@ -798,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 @@ -819,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 @@ -843,14 +846,13 @@ def serialize_unicode(cls, data): pass try: - if isinstance(data, unicode): + if isinstance(data, unicode): # type: ignore # Don't change it, JSON and XML ElementTree are totally able # to serialize correctly u'' strings return data except NameError: return str(data) - else: - return str(data) + return str(data) def serialize_iter(self, data, iter_type, div=None, **kwargs): """Serialize iterable. @@ -860,13 +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'. + Defaults to False. :rtype: list, str + :return: serialized iterable """ if isinstance(data, str): raise SerializationError("Refuse str type as a valid iter type.") @@ -878,9 +880,14 @@ def serialize_iter(self, data, iter_type, div=None, **kwargs): for d in data: try: serialized.append(self.serialize_data(d, iter_type, **kwargs)) - except ValueError: + except ValueError as err: + if isinstance(err, SerializationError): + raise serialized.append(None) + if kwargs.get("do_quote", False): + serialized = ["" if s is None else quote(str(s), safe="") for s in serialized] + if div: serialized = ["" if s is None else str(s) for s in serialized] serialized = div.join(serialized) @@ -916,16 +923,17 @@ def serialize_dict(self, attr, dict_type, **kwargs): :param dict attr: Object to be serialized. :param str dict_type: Type of object in the dictionary. - :param bool required: Whether the objects in the dictionary must - not be None or empty. :rtype: dict + :return: serialized dictionary """ serialization_ctxt = kwargs.get("serialization_ctxt", {}) serialized = {} for key, value in attr.items(): try: serialized[self.serialize_unicode(key)] = self.serialize_data(value, dict_type, **kwargs) - except ValueError: + except ValueError as err: + if isinstance(err, SerializationError): + raise serialized[self.serialize_unicode(key)] = None if "xml" in serialization_ctxt: @@ -940,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 @@ -948,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 @@ -958,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) @@ -972,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: @@ -1001,58 +1010,63 @@ def serialize_enum(attr, enum_obj=None): except AttributeError: result = attr try: - enum_obj(result) + enum_obj(result) # type: ignore return result - except ValueError: - for enum_value in enum_obj: + 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) @@ -1060,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) @@ -1074,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], @@ -1110,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) @@ -1135,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 @@ -1155,16 +1174,17 @@ def serialize_unix(attr, **kwargs): if not attr.tzinfo: _LOGGER.warning("Datetime with no tzinfo will be considered UTC.") return int(calendar.timegm(attr.utctimetuple())) - except AttributeError: - raise TypeError("Unix time object must be valid Datetime object.") + except AttributeError as exc: + raise TypeError("Unix time object must be valid Datetime object.") from exc -def rest_key_extractor(attr, attr_desc, data): +def rest_key_extractor(attr, attr_desc, data): # pylint: disable=unused-argument key = attr_desc["key"] working_data = data while "." in key: - dict_keys = _FLATTEN.split(key) + # Need the cast, as for some reasons "split" is typed as list[str | Any] + dict_keys = cast(List[str], _FLATTEN.split(key)) if len(dict_keys) == 1: key = _decode_attribute_map_key(dict_keys[0]) break @@ -1173,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 @@ -1194,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:]) @@ -1202,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) @@ -1245,11 +1277,11 @@ def _extract_name_from_internal_type(internal_type): xml_name = internal_type_xml_map.get("name", internal_type.__name__) xml_ns = internal_type_xml_map.get("ns", None) if xml_ns: - xml_name = "{}{}".format(xml_ns, xml_name) + xml_name = "{{{}}}{}".format(xml_ns, xml_name) return xml_name -def xml_key_extractor(attr, attr_desc, data): +def xml_key_extractor(attr, attr_desc, data): # pylint: disable=unused-argument,too-many-return-statements if isinstance(data, dict): return None @@ -1269,7 +1301,7 @@ def xml_key_extractor(attr, attr_desc, data): # Integrate namespace if necessary xml_ns = xml_desc.get("ns", internal_type_xml_map.get("ns", None)) if xml_ns: - xml_name = "{}{}".format(xml_ns, xml_name) + xml_name = "{{{}}}{}".format(xml_ns, xml_name) # If it's an attribute, that's simple if xml_desc.get("attr", False): @@ -1301,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: @@ -1324,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. @@ -1333,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=None): + def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: self.deserialize_type = { "iso-8601": Deserializer.deserialize_iso, "rfc-1123": Deserializer.deserialize_rfc, @@ -1355,7 +1386,7 @@ def __init__(self, classes=None): "duration": (isodate.Duration, datetime.timedelta), "iso-8601": (datetime.datetime), } - self.dependencies = dict(classes) if classes else {} + self.dependencies: Dict[str, type] = dict(classes) if classes else {} self.key_extractors = [rest_key_extractor, xml_key_extractor] # Additional properties only works if the "rest_key_extractor" is used to # extract the keys. Making it to work whatever the key extractor is too much @@ -1371,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) @@ -1408,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 + 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"... @@ -1444,11 +1477,10 @@ def _deserialize(self, target_obj, data): value = self.deserialize_data(raw_value, attr_desc["type"]) d_attrs[attr] = value except (AttributeError, TypeError, KeyError) as err: - msg = "Unable to deserialize to object: " + class_name - raise_with_traceback(DeserializationError, msg, err) - else: - additional_properties = self._build_additional_properties(attributes, data) - return self._instantiate_model(response, d_attrs, additional_properties) + msg = "Unable to deserialize to object: " + class_name # type: ignore + 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: @@ -1474,22 +1506,24 @@ def _classify_target(self, target, data): Once classification has been determined, initialize object. :param str target: The target object type to deserialize to. - :param str/dict data: The response data to deseralize. + :param str/dict data: The response data to deserialize. + :return: The classified target object and its class name. + :rtype: tuple """ if target is None: return None, None - if isinstance(target, basestring): + if isinstance(target, str): try: target = self.dependencies[target] except KeyError: return target, target try: - target = target._classify(data, self.dependencies) + target = target._classify(data, self.dependencies) # type: ignore # pylint: disable=protected-access except AttributeError: pass # Target is not a Model, no classify - return target, target.__class__.__name__ + return target, target.__class__.__name__ # type: ignore def failsafe_deserialize(self, target_obj, data, content_type=None): """Ignores any errors encountered in deserialization, @@ -1499,12 +1533,14 @@ def failsafe_deserialize(self, target_obj, data, content_type=None): a deserialization error. :param str target_obj: The target object type to deserialize to. - :param str/dict data: The response data to deseralize. + :param str/dict data: The response data to deserialize. :param str content_type: Swagger "produces" if available. + :return: Deserialized object. + :rtype: object """ try: return self(target_obj, data, content_type=content_type) - except: + except: # pylint: disable=bare-except _LOGGER.debug( "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True ) @@ -1522,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", {}) @@ -1542,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"): - return RawDeserializer.deserialize_from_text(raw_data, content_type) + 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) - raise DeserializationError(msg + str(err)) + msg = "Unable to deserialize {} into model {}. ".format(kwargs, response) # type: ignore + raise DeserializationError(msg + str(err)) from err else: try: for attr, value in attrs.items(): @@ -1575,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 @@ -1597,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) @@ -1616,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: @@ -1641,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): @@ -1651,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: @@ -1690,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 @@ -1702,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 @@ -1713,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): @@ -1738,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, @@ -1747,12 +1803,11 @@ def deserialize_unicode(data): # Consider this is real string try: - if isinstance(data, unicode): + if isinstance(data, unicode): # type: ignore return data except NameError: return str(data) - else: - return str(data) + return str(data) @staticmethod def deserialize_enum(data, enum_obj): @@ -1764,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: @@ -1772,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: @@ -1793,25 +1848,27 @@ 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 - return bytearray(b64decode(attr)) + return bytearray(b64decode(attr)) # type: ignore @staticmethod 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 - padding = "=" * (3 - (len(attr) + 3) % 4) - attr = attr + padding + padding = "=" * (3 - (len(attr) + 3) % 4) # type: ignore + attr = attr + padding # type: ignore encoded = attr.replace("-", "+").replace("_", "/") return b64decode(encoded) @@ -1820,36 +1877,39 @@ 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) + 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 - return _long_type(attr) + return _long_type(attr) # type: ignore @staticmethod 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 @@ -1857,36 +1917,37 @@ 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): + 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 - if re.search(r"[^\W\d_]", attr, re.I + re.U): + if re.search(r"[^\W\d_]", attr, re.I + re.U): # type: ignore raise DeserializationError("Date must have only digits and -. Received: %s" % attr) return isodate.parse_time(attr) @@ -1895,36 +1956,37 @@ 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) + 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 try: - attr = attr.upper() + attr = attr.upper() # type: ignore match = Deserializer.valid_date.match(attr) if not match: raise ValueError("Invalid datetime string: " + attr) @@ -1946,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): @@ -1956,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) + 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/peering/azure-mgmt-peering/azure/mgmt/peering/aio/_vendor.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_utils/utils.py similarity index 58% rename from sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/_vendor.py rename to sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_utils/utils.py index 969390d27547..39b612f39a9b 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/_vendor.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_utils/utils.py @@ -6,23 +6,20 @@ # -------------------------------------------------------------------------- from abc import ABC -from typing import TYPE_CHECKING - -from azure.core.pipeline.transport import HttpRequest - -from ._configuration import PeeringManagementClientConfiguration +from typing import Generic, TYPE_CHECKING, TypeVar if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core import AsyncPipelineClient + from .serialization import Deserializer, Serializer + - from .._serialization import Deserializer, Serializer +TClient = TypeVar("TClient") +TConfig = TypeVar("TConfig") -class PeeringManagementClientMixinABC(ABC): +class ClientMixinABC(ABC, Generic[TClient, TConfig]): """DO NOT use this class. It is for internal typing use only.""" - _client: "AsyncPipelineClient" - _config: PeeringManagementClientConfiguration + _client: TClient + _config: TConfig _serialize: "Serializer" _deserialize: "Deserializer" diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_vendor.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_vendor.py deleted file mode 100644 index 5177ea4b75f9..000000000000 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_vendor.py +++ /dev/null @@ -1,47 +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 abc import ABC -from typing import TYPE_CHECKING - -from azure.core.pipeline.transport import HttpRequest - -from ._configuration import PeeringManagementClientConfiguration - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from azure.core import PipelineClient - - from ._serialization import Deserializer, Serializer - - -def _convert_request(request, files=None): - data = request.content if not files else None - request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) - if files: - request.set_formdata_body(files) - return request - - -def _format_url_section(template, **kwargs): - components = template.split("/") - while components: - try: - return template.format(**kwargs) - except KeyError as key: - formatted_components = template.split("/") - components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] - template = "/".join(components) - - -class PeeringManagementClientMixinABC(ABC): - """DO NOT use this class. It is for internal typing use only.""" - - _client: "PipelineClient" - _config: PeeringManagementClientConfiguration - _serialize: "Serializer" - _deserialize: "Deserializer" diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_version.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_version.py index e32dc6ec4218..48944bf3938a 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_version.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "2.0.0b1" +VERSION = "2.0.0" diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/__init__.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/__init__.py index 4887b777dceb..a8accdc79dd0 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/__init__.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/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 ._peering_management_client import PeeringManagementClient +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._peering_management_client import PeeringManagementClient # type: ignore try: from ._patch import __all__ as _patch_all - from ._patch import * # type: ignore # 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__ = [ "PeeringManagementClient", ] -__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/peering/azure-mgmt-peering/azure/mgmt/peering/aio/_configuration.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/_configuration.py index 29ad32857080..756bb7728186 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/_configuration.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/_configuration.py @@ -6,26 +6,18 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys 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 sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports - if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials_async import AsyncTokenCredential -class PeeringManagementClientConfiguration(Configuration): # pylint: disable=too-many-instance-attributes +class PeeringManagementClientConfiguration: # pylint: disable=too-many-instance-attributes """Configuration for PeeringManagementClient. Note that all parameters used to create this instance are saved as instance @@ -35,14 +27,13 @@ class PeeringManagementClientConfiguration(Configuration): # pylint: disable=to :type credential: ~azure.core.credentials_async.AsyncTokenCredential :param subscription_id: The Azure subscription ID. Required. :type subscription_id: str - :keyword api_version: Api Version. Default value is "2022-10-01". Note that overriding this + :keyword api_version: Api Version. Default value is "2025-05-01". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: - super(PeeringManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop("api_version", "2022-10-01") # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", "2025-05-01") if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -54,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-peering/{}".format(VERSION)) + self.polling_interval = kwargs.get("polling_interval", 30) self._configure(**kwargs) def _configure(self, **kwargs: Any) -> None: @@ -62,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/peering/azure-mgmt-peering/azure/mgmt/peering/aio/_peering_management_client.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/_peering_management_client.py index 8a4efe8c7103..2ba1f50a2628 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/_peering_management_client.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/_peering_management_client.py @@ -7,13 +7,18 @@ # -------------------------------------------------------------------------- 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 -from .._serialization import Deserializer, Serializer +from .. import models as _models +from .._utils.serialization import Deserializer, Serializer from ._configuration import PeeringManagementClientConfiguration from .operations import ( CdnPeeringPrefixesOperations, @@ -37,13 +42,10 @@ ) if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials_async import AsyncTokenCredential -class PeeringManagementClient( - PeeringManagementClientOperationsMixin -): # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes +class PeeringManagementClient(PeeringManagementClientOperationsMixin): # pylint: disable=too-many-instance-attributes """Peering Client. :ivar cdn_peering_prefixes: CdnPeeringPrefixesOperations operations @@ -88,26 +90,48 @@ class PeeringManagementClient( :type credential: ~azure.core.credentials_async.AsyncTokenCredential :param subscription_id: The Azure subscription ID. 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 "2022-10-01". Note that overriding this + :keyword api_version: Api Version. Default value is "2025-05-01". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ def __init__( - self, - credential: "AsyncTokenCredential", - subscription_id: str, - base_url: 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 = PeeringManagementClientConfiguration( - credential=credential, subscription_id=subscription_id, **kwargs + credential=credential, subscription_id=subscription_id, credential_scopes=credential_scopes, **kwargs ) - self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **kwargs) - client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} + _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 + ) + + client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) self._deserialize = Deserializer(client_models) self._serialize.client_side_validation = False @@ -147,7 +171,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 @@ -167,14 +193,14 @@ def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncH request_copy = deepcopy(request) request_copy.url = self._client.format_url(request_copy.url) - return self._client.send_request(request_copy, **kwargs) + return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore async def close(self) -> None: await self._client.close() - async def __aenter__(self) -> "PeeringManagementClient": + async def __aenter__(self) -> Self: await self._client.__aenter__() return self - async def __aexit__(self, *exc_details) -> None: + async def __aexit__(self, *exc_details: Any) -> None: await self._client.__aexit__(*exc_details) diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/__init__.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/__init__.py index 3a7f6307d71e..847358e61cce 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/__init__.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/__init__.py @@ -5,28 +5,34 @@ # 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 ._cdn_peering_prefixes_operations import CdnPeeringPrefixesOperations -from ._peering_management_client_operations import PeeringManagementClientOperationsMixin -from ._legacy_peerings_operations import LegacyPeeringsOperations -from ._looking_glass_operations import LookingGlassOperations -from ._operations import Operations -from ._peer_asns_operations import PeerAsnsOperations -from ._peering_locations_operations import PeeringLocationsOperations -from ._registered_asns_operations import RegisteredAsnsOperations -from ._registered_prefixes_operations import RegisteredPrefixesOperations -from ._peerings_operations import PeeringsOperations -from ._received_routes_operations import ReceivedRoutesOperations -from ._connection_monitor_tests_operations import ConnectionMonitorTestsOperations -from ._peering_service_countries_operations import PeeringServiceCountriesOperations -from ._peering_service_locations_operations import PeeringServiceLocationsOperations -from ._prefixes_operations import PrefixesOperations -from ._peering_service_providers_operations import PeeringServiceProvidersOperations -from ._peering_services_operations import PeeringServicesOperations -from ._rp_unbilled_prefixes_operations import RpUnbilledPrefixesOperations +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._cdn_peering_prefixes_operations import CdnPeeringPrefixesOperations # type: ignore +from ._peering_management_client_operations import PeeringManagementClientOperationsMixin # type: ignore +from ._legacy_peerings_operations import LegacyPeeringsOperations # type: ignore +from ._looking_glass_operations import LookingGlassOperations # type: ignore +from ._operations import Operations # type: ignore +from ._peer_asns_operations import PeerAsnsOperations # type: ignore +from ._peering_locations_operations import PeeringLocationsOperations # type: ignore +from ._registered_asns_operations import RegisteredAsnsOperations # type: ignore +from ._registered_prefixes_operations import RegisteredPrefixesOperations # type: ignore +from ._peerings_operations import PeeringsOperations # type: ignore +from ._received_routes_operations import ReceivedRoutesOperations # type: ignore +from ._connection_monitor_tests_operations import ConnectionMonitorTestsOperations # type: ignore +from ._peering_service_countries_operations import PeeringServiceCountriesOperations # type: ignore +from ._peering_service_locations_operations import PeeringServiceLocationsOperations # type: ignore +from ._prefixes_operations import PrefixesOperations # type: ignore +from ._peering_service_providers_operations import PeeringServiceProvidersOperations # type: ignore +from ._peering_services_operations import PeeringServicesOperations # type: ignore +from ._rp_unbilled_prefixes_operations import RpUnbilledPrefixesOperations # type: ignore from ._patch import __all__ as _patch_all -from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ @@ -49,5 +55,5 @@ "PeeringServicesOperations", "RpUnbilledPrefixesOperations", ] -__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/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_cdn_peering_prefixes_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_cdn_peering_prefixes_operations.py index c5fb1e8b3919..e68d290d9caa 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_cdn_peering_prefixes_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_cdn_peering_prefixes_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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, @@ -20,21 +20,16 @@ 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 ..._utils.serialization import Deserializer, Serializer from ...operations._cdn_peering_prefixes_operations import build_list_request -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -53,10 +48,10 @@ class CdnPeeringPrefixesOperations: 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: PeeringManagementClientConfiguration = 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, peering_location: str, **kwargs: Any) -> AsyncIterable["_models.CdnPeeringPrefix"]: @@ -64,7 +59,6 @@ def list(self, peering_location: str, **kwargs: Any) -> AsyncIterable["_models.C :param peering_location: The peering location. Required. :type peering_location: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either CdnPeeringPrefix or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.peering.models.CdnPeeringPrefix] :raises ~azure.core.exceptions.HttpResponseError: @@ -72,12 +66,10 @@ def list(self, peering_location: str, **kwargs: Any) -> AsyncIterable["_models.C _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.CdnPeeringPrefixListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.CdnPeeringPrefixListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -88,16 +80,14 @@ def list(self, peering_location: str, **kwargs: Any) -> AsyncIterable["_models.C def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( subscription_id=self._config.subscription_id, peering_location=peering_location, api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -109,26 +99,26 @@ 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) # type: ignore - 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("CdnPeeringPrefixListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -140,5 +130,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/cdnPeeringPrefixes"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_connection_monitor_tests_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_connection_monitor_tests_operations.py index ed4f248abe32..20cef8e098a7 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_connection_monitor_tests_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_connection_monitor_tests_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,12 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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,27 +21,22 @@ 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 ..._utils.serialization import Deserializer, Serializer from ...operations._connection_monitor_tests_operations import ( build_create_or_update_request, build_delete_request, build_get_request, build_list_by_peering_service_request, ) -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -59,10 +55,10 @@ class ConnectionMonitorTestsOperations: 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: PeeringManagementClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace_async async def get( @@ -77,12 +73,11 @@ async def get( :type peering_service_name: str :param connection_monitor_test_name: The name of the connection monitor test. Required. :type connection_monitor_test_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: ConnectionMonitorTest or the result of cls(response) :rtype: ~azure.mgmt.peering.models.ConnectionMonitorTest :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -93,26 +88,23 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ConnectionMonitorTest] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.ConnectionMonitorTest] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, connection_monitor_test_name=connection_monitor_test_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -122,14 +114,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("ConnectionMonitorTest", pipeline_response) + deserialized = self._deserialize("ConnectionMonitorTest", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/connectionMonitorTests/{connectionMonitorTestName}"} # type: ignore + return deserialized # type: ignore @overload async def create_or_update( @@ -157,7 +147,6 @@ async def create_or_update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: ConnectionMonitorTest or the result of cls(response) :rtype: ~azure.mgmt.peering.models.ConnectionMonitorTest :raises ~azure.core.exceptions.HttpResponseError: @@ -169,7 +158,7 @@ async def create_or_update( resource_group_name: str, peering_service_name: str, connection_monitor_test_name: str, - connection_monitor_test: IO, + connection_monitor_test: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -185,11 +174,10 @@ async def create_or_update( :type connection_monitor_test_name: str :param connection_monitor_test: The properties needed to create a connection monitor test. Required. - :type connection_monitor_test: IO + :type connection_monitor_test: 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: ConnectionMonitorTest or the result of cls(response) :rtype: ~azure.mgmt.peering.models.ConnectionMonitorTest :raises ~azure.core.exceptions.HttpResponseError: @@ -201,7 +189,7 @@ async def create_or_update( resource_group_name: str, peering_service_name: str, connection_monitor_test_name: str, - connection_monitor_test: Union[_models.ConnectionMonitorTest, IO], + connection_monitor_test: Union[_models.ConnectionMonitorTest, IO[bytes]], **kwargs: Any ) -> _models.ConnectionMonitorTest: """Creates or updates a connection monitor test with the specified name under the given @@ -214,17 +202,13 @@ async def create_or_update( :param connection_monitor_test_name: The name of the connection monitor test. Required. :type connection_monitor_test_name: str :param connection_monitor_test: The properties needed to create a connection monitor test. Is - either a model type or a IO type. Required. - :type connection_monitor_test: ~azure.mgmt.peering.models.ConnectionMonitorTest 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 + either a ConnectionMonitorTest type or a IO[bytes] type. Required. + :type connection_monitor_test: ~azure.mgmt.peering.models.ConnectionMonitorTest or IO[bytes] :return: ConnectionMonitorTest or the result of cls(response) :rtype: ~azure.mgmt.peering.models.ConnectionMonitorTest :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -235,21 +219,19 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ConnectionMonitorTest] + 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.ConnectionMonitorTest] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(connection_monitor_test, (IO, bytes)): + if isinstance(connection_monitor_test, (IOBase, bytes)): _content = connection_monitor_test else: _json = self._serialize.body(connection_monitor_test, "ConnectionMonitorTest") - request = build_create_or_update_request( + _request = build_create_or_update_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, connection_monitor_test_name=connection_monitor_test_name, @@ -258,15 +240,14 @@ async def create_or_update( content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -276,21 +257,15 @@ async def create_or_update( 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("ConnectionMonitorTest", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("ConnectionMonitorTest", pipeline_response) + deserialized = self._deserialize("ConnectionMonitorTest", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/connectionMonitorTests/{connectionMonitorTestName}"} # type: ignore + return deserialized # type: ignore @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements + async def delete( self, resource_group_name: str, peering_service_name: str, connection_monitor_test_name: str, **kwargs: Any ) -> None: """Deletes an existing connection monitor test with the specified name under the given @@ -302,12 +277,11 @@ async def delete( # pylint: disable=inconsistent-return-statements :type peering_service_name: str :param connection_monitor_test_name: The name of the connection monitor test. Required. :type connection_monitor_test_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, @@ -318,26 +292,23 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + 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, peering_service_name=peering_service_name, connection_monitor_test_name=connection_monitor_test_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -348,9 +319,7 @@ 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.Peering/peeringServices/{peeringServiceName}/connectionMonitorTests/{connectionMonitorTestName}"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore @distributed_trace def list_by_peering_service( @@ -363,7 +332,6 @@ def list_by_peering_service( :type resource_group_name: str :param peering_service_name: The name of the peering service. Required. :type peering_service_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either ConnectionMonitorTest or the result of cls(response) :rtype: @@ -373,12 +341,10 @@ def list_by_peering_service( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ConnectionMonitorTestListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.ConnectionMonitorTestListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -389,17 +355,15 @@ def list_by_peering_service( def prepare_request(next_link=None): if not next_link: - request = build_list_by_peering_service_request( + _request = build_list_by_peering_service_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_peering_service.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -411,26 +375,26 @@ 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) # type: ignore - 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("ConnectionMonitorTestListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -442,5 +406,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list_by_peering_service.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/connectionMonitorTests"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_legacy_peerings_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_legacy_peerings_operations.py index 90748c93ece5..c2a979a42348 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_legacy_peerings_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_legacy_peerings_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from collections.abc import MutableMapping from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar, Union import urllib.parse +from azure.core import AsyncPipelineClient from azure.core.async_paging import AsyncItemPaged, AsyncList from azure.core.exceptions import ( ClientAuthenticationError, @@ -20,21 +20,16 @@ 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 ..._utils.serialization import Deserializer, Serializer from ...operations._legacy_peerings_operations import build_list_request -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -53,10 +48,10 @@ class LegacyPeeringsOperations: 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: PeeringManagementClientConfiguration = 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( @@ -77,9 +72,9 @@ def list( :param asn: The ASN number associated with a legacy peering. Default value is None. :type asn: int :param direct_peering_type: The direct peering type. Known values are: "Edge", "Transit", - "Cdn", "Internal", "Ix", "IxRs", "Voice", and "EdgeZoneForOperators". Default value is None. + "Cdn", "Internal", "Ix", "IxRs", "Voice", "EdgeZoneForOperators", and "PeerProp". Default value + is None. :type direct_peering_type: str or ~azure.mgmt.peering.models.DirectPeeringType - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either Peering or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.peering.models.Peering] :raises ~azure.core.exceptions.HttpResponseError: @@ -87,12 +82,10 @@ def list( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -103,19 +96,17 @@ def list( def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( subscription_id=self._config.subscription_id, peering_location=peering_location, kind=kind, asn=asn, direct_peering_type=direct_peering_type, api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -127,26 +118,26 @@ 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) # type: ignore - 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("PeeringListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -158,5 +149,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/legacyPeerings"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_looking_glass_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_looking_glass_operations.py index 6055fbcaa7ef..9a602b6a3de3 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_looking_glass_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_looking_glass_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,9 +5,10 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from collections.abc import MutableMapping from typing import Any, Callable, Dict, Optional, TypeVar, Union +from azure.core import AsyncPipelineClient from azure.core.exceptions import ( ClientAuthenticationError, HttpResponseError, @@ -18,21 +18,16 @@ map_error, ) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse -from azure.core.rest import HttpRequest +from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.core.tracing.decorator_async import distributed_trace_async from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat from ... import models as _models -from ..._vendor import _convert_request +from ..._utils.serialization import Deserializer, Serializer from ...operations._looking_glass_operations import build_invoke_request -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -51,10 +46,10 @@ class LookingGlassOperations: 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: PeeringManagementClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace_async async def invoke( @@ -77,12 +72,11 @@ async def invoke( :type source_location: str :param destination_ip: The IP address of the destination. Required. :type destination_ip: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: LookingGlassOutput or the result of cls(response) :rtype: ~azure.mgmt.peering.models.LookingGlassOutput :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -93,27 +87,24 @@ async def invoke( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.LookingGlassOutput] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.LookingGlassOutput] = kwargs.pop("cls", None) - request = build_invoke_request( + _request = build_invoke_request( subscription_id=self._config.subscription_id, command=command, source_type=source_type, source_location=source_location, destination_ip=destination_ip, api_version=api_version, - template_url=self.invoke.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -123,11 +114,9 @@ async def invoke( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("LookingGlassOutput", pipeline_response) + deserialized = self._deserialize("LookingGlassOutput", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - invoke.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/lookingGlass"} # type: ignore + return deserialized # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_operations.py index b2022d4a4a15..1c8241e1577c 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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, @@ -20,21 +20,16 @@ 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 ..._utils.serialization import Deserializer, Serializer from ...operations._operations import build_list_request -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -53,16 +48,15 @@ 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: PeeringManagementClientConfiguration = 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"]: """Lists all of the available API operations for peering resources. - :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.peering.models.Operation] :raises ~azure.core.exceptions.HttpResponseError: @@ -70,12 +64,10 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] + 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, @@ -86,14 +78,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) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -105,26 +95,26 @@ 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) # type: ignore - 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) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -136,5 +126,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list.metadata = {"url": "/providers/Microsoft.Peering/operations"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peer_asns_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peer_asns_operations.py index bee36e9ec7ed..2873e23b4b54 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peer_asns_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peer_asns_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,12 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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,27 +21,22 @@ 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 ..._utils.serialization import Deserializer, Serializer from ...operations._peer_asns_operations import ( build_create_or_update_request, build_delete_request, build_get_request, build_list_by_subscription_request, ) -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -59,10 +55,10 @@ class PeerAsnsOperations: 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: PeeringManagementClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace_async async def get(self, peer_asn_name: str, **kwargs: Any) -> _models.PeerAsn: @@ -70,12 +66,11 @@ async def get(self, peer_asn_name: str, **kwargs: Any) -> _models.PeerAsn: :param peer_asn_name: The peer ASN name. Required. :type peer_asn_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeerAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeerAsn :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -86,24 +81,21 @@ async def get(self, peer_asn_name: str, **kwargs: Any) -> _models.PeerAsn: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeerAsn] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeerAsn] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( peer_asn_name=peer_asn_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -113,14 +105,12 @@ async def get(self, peer_asn_name: str, **kwargs: Any) -> _models.PeerAsn: error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("PeerAsn", pipeline_response) + deserialized = self._deserialize("PeerAsn", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peerAsns/{peerAsnName}"} # type: ignore + return deserialized # type: ignore @overload async def create_or_update( @@ -136,7 +126,6 @@ async def create_or_update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeerAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeerAsn :raises ~azure.core.exceptions.HttpResponseError: @@ -144,7 +133,7 @@ async def create_or_update( @overload async def create_or_update( - self, peer_asn_name: str, peer_asn: IO, *, content_type: str = "application/json", **kwargs: Any + self, peer_asn_name: str, peer_asn: IO[bytes], *, content_type: str = "application/json", **kwargs: Any ) -> _models.PeerAsn: """Creates a new peer ASN or updates an existing peer ASN with the specified name under the given subscription. @@ -152,11 +141,10 @@ async def create_or_update( :param peer_asn_name: The peer ASN name. Required. :type peer_asn_name: str :param peer_asn: The peer ASN. Required. - :type peer_asn: IO + :type peer_asn: 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: PeerAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeerAsn :raises ~azure.core.exceptions.HttpResponseError: @@ -164,24 +152,20 @@ async def create_or_update( @distributed_trace_async async def create_or_update( - self, peer_asn_name: str, peer_asn: Union[_models.PeerAsn, IO], **kwargs: Any + self, peer_asn_name: str, peer_asn: Union[_models.PeerAsn, IO[bytes]], **kwargs: Any ) -> _models.PeerAsn: """Creates a new peer ASN or updates an existing peer ASN with the specified name under the given subscription. :param peer_asn_name: The peer ASN name. Required. :type peer_asn_name: str - :param peer_asn: The peer ASN. Is either a model type or a IO type. Required. - :type peer_asn: ~azure.mgmt.peering.models.PeerAsn 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 peer_asn: The peer ASN. Is either a PeerAsn type or a IO[bytes] type. Required. + :type peer_asn: ~azure.mgmt.peering.models.PeerAsn or IO[bytes] :return: PeerAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeerAsn :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -192,36 +176,33 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeerAsn] + 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.PeerAsn] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(peer_asn, (IO, bytes)): + if isinstance(peer_asn, (IOBase, bytes)): _content = peer_asn else: _json = self._serialize.body(peer_asn, "PeerAsn") - request = build_create_or_update_request( + _request = build_create_or_update_request( peer_asn_name=peer_asn_name, subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -231,31 +212,24 @@ async def create_or_update( 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("PeerAsn", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("PeerAsn", pipeline_response) + deserialized = self._deserialize("PeerAsn", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peerAsns/{peerAsnName}"} # type: ignore + return deserialized # type: ignore @distributed_trace_async - async def delete(self, peer_asn_name: str, **kwargs: Any) -> None: # pylint: disable=inconsistent-return-statements + async def delete(self, peer_asn_name: str, **kwargs: Any) -> None: """Deletes an existing peer ASN with the specified name under the given subscription. :param peer_asn_name: The peer ASN name. Required. :type peer_asn_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, @@ -266,24 +240,21 @@ async def delete(self, peer_asn_name: str, **kwargs: Any) -> None: # pylint: di _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + 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( peer_asn_name=peer_asn_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -294,15 +265,12 @@ async def delete(self, peer_asn_name: str, **kwargs: Any) -> None: # pylint: di raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: - return cls(pipeline_response, None, {}) - - delete.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peerAsns/{peerAsnName}"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore @distributed_trace def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.PeerAsn"]: """Lists all of the peer ASNs under the given subscription. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeerAsn or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.peering.models.PeerAsn] :raises ~azure.core.exceptions.HttpResponseError: @@ -310,12 +278,10 @@ def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.PeerAsn" _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeerAsnListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeerAsnListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -326,15 +292,13 @@ def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.PeerAsn" 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) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -346,26 +310,26 @@ 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) # type: ignore - 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("PeerAsnListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -377,5 +341,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peerAsns"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_locations_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_locations_operations.py index c4da3e7e4065..baddaff010c2 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_locations_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_locations_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from collections.abc import MutableMapping from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar, Union import urllib.parse +from azure.core import AsyncPipelineClient from azure.core.async_paging import AsyncItemPaged, AsyncList from azure.core.exceptions import ( ClientAuthenticationError, @@ -20,21 +20,16 @@ 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 ..._utils.serialization import Deserializer, Serializer from ...operations._peering_locations_operations import build_list_request -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -53,10 +48,10 @@ class PeeringLocationsOperations: 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: PeeringManagementClientConfiguration = 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( @@ -70,9 +65,9 @@ def list( :param kind: The kind of the peering. Known values are: "Direct" and "Exchange". Required. :type kind: str or ~azure.mgmt.peering.models.PeeringLocationsKind :param direct_peering_type: The type of direct peering. Known values are: "Edge", "Transit", - "Cdn", "Internal", "Ix", "IxRs", "Voice", and "EdgeZoneForOperators". Default value is None. + "Cdn", "Internal", "Ix", "IxRs", "Voice", "EdgeZoneForOperators", and "PeerProp". Default value + is None. :type direct_peering_type: str or ~azure.mgmt.peering.models.PeeringLocationsDirectPeeringType - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringLocation or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.peering.models.PeeringLocation] :raises ~azure.core.exceptions.HttpResponseError: @@ -80,12 +75,10 @@ def list( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringLocationListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringLocationListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -96,17 +89,15 @@ def list( def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( subscription_id=self._config.subscription_id, kind=kind, direct_peering_type=direct_peering_type, api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -118,26 +109,26 @@ 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) # type: ignore - 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("PeeringLocationListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -149,5 +140,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peeringLocations"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_management_client_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_management_client_operations.py index 45f08e3d4752..aa6d66168175 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_management_client_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_management_client_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,9 +6,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from collections.abc import MutableMapping +from io import IOBase from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload +from azure.core import AsyncPipelineClient from azure.core.exceptions import ( ClientAuthenticationError, HttpResponseError, @@ -18,26 +20,22 @@ map_error, ) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse -from azure.core.rest import HttpRequest +from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.core.tracing.decorator_async import distributed_trace_async from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat from ... import models as _models -from ..._vendor import _convert_request +from ..._utils.utils import ClientMixinABC from ...operations._peering_management_client_operations import build_check_service_provider_availability_request -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] -class PeeringManagementClientOperationsMixin(PeeringManagementClientMixinABC): +class PeeringManagementClientOperationsMixin(ClientMixinABC[AsyncPipelineClient, PeeringManagementClientConfiguration]): + @overload async def check_service_provider_availability( self, @@ -55,7 +53,6 @@ async def check_service_provider_availability( :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: Enum0 or the result of cls(response) :rtype: str or ~azure.mgmt.peering.models.Enum0 :raises ~azure.core.exceptions.HttpResponseError: @@ -63,17 +60,20 @@ async def check_service_provider_availability( @overload async def check_service_provider_availability( - self, check_service_provider_availability_input: IO, *, content_type: str = "application/json", **kwargs: Any + self, + check_service_provider_availability_input: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any ) -> Union[str, _models.Enum0]: """Checks if the peering service provider is present within 1000 miles of customer's location. :param check_service_provider_availability_input: The CheckServiceProviderAvailabilityInput indicating customer location and service provider. Required. - :type check_service_provider_availability_input: IO + :type check_service_provider_availability_input: 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: Enum0 or the result of cls(response) :rtype: str or ~azure.mgmt.peering.models.Enum0 :raises ~azure.core.exceptions.HttpResponseError: @@ -82,25 +82,21 @@ async def check_service_provider_availability( @distributed_trace_async async def check_service_provider_availability( self, - check_service_provider_availability_input: Union[_models.CheckServiceProviderAvailabilityInput, IO], + check_service_provider_availability_input: Union[_models.CheckServiceProviderAvailabilityInput, IO[bytes]], **kwargs: Any ) -> Union[str, _models.Enum0]: """Checks if the peering service provider is present within 1000 miles of customer's location. :param check_service_provider_availability_input: The CheckServiceProviderAvailabilityInput - indicating customer location and service provider. Is either a model type or a IO type. - Required. + indicating customer location and service provider. Is either a + CheckServiceProviderAvailabilityInput type or a IO[bytes] type. Required. :type check_service_provider_availability_input: - ~azure.mgmt.peering.models.CheckServiceProviderAvailabilityInput 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.peering.models.CheckServiceProviderAvailabilityInput or IO[bytes] :return: Enum0 or the result of cls(response) :rtype: str or ~azure.mgmt.peering.models.Enum0 :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -111,37 +107,34 @@ async def check_service_provider_availability( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[Union[str, _models.Enum0]] + 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[Union[str, _models.Enum0]] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(check_service_provider_availability_input, (IO, bytes)): + if isinstance(check_service_provider_availability_input, (IOBase, bytes)): _content = check_service_provider_availability_input else: _json = self._serialize.body( check_service_provider_availability_input, "CheckServiceProviderAvailabilityInput" ) - request = build_check_service_provider_availability_request( + _request = build_check_service_provider_availability_request( subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, json=_json, content=_content, - template_url=self.check_service_provider_availability.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -151,11 +144,9 @@ async def check_service_provider_availability( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("str", pipeline_response) + deserialized = self._deserialize("str", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - check_service_provider_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/checkServiceProviderAvailability"} # type: ignore + return deserialized # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_service_countries_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_service_countries_operations.py index dbca4f1757d2..6d0792c5c1fc 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_service_countries_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_service_countries_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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, @@ -20,21 +20,16 @@ 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 ..._utils.serialization import Deserializer, Serializer from ...operations._peering_service_countries_operations import build_list_request -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -53,16 +48,15 @@ class PeeringServiceCountriesOperations: 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: PeeringManagementClientConfiguration = 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.PeeringServiceCountry"]: """Lists all of the available countries for peering service. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringServiceCountry or the result of cls(response) :rtype: @@ -72,12 +66,10 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.PeeringServiceCountry"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServiceCountryListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringServiceCountryListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -88,15 +80,13 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.PeeringServiceCountry"]: def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -108,26 +98,26 @@ 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) # type: ignore - 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("PeeringServiceCountryListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -139,5 +129,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peeringServiceCountries"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_service_locations_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_service_locations_operations.py index 195716047020..9c61eb515f67 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_service_locations_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_service_locations_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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, @@ -20,21 +20,16 @@ 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 ..._utils.serialization import Deserializer, Serializer from ...operations._peering_service_locations_operations import build_list_request -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -53,10 +48,10 @@ class PeeringServiceLocationsOperations: 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: PeeringManagementClientConfiguration = 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, country: Optional[str] = None, **kwargs: Any) -> AsyncIterable["_models.PeeringServiceLocation"]: @@ -65,7 +60,6 @@ def list(self, country: Optional[str] = None, **kwargs: Any) -> AsyncIterable["_ :param country: The country of interest, in which the locations are to be present. Default value is None. :type country: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringServiceLocation or the result of cls(response) :rtype: @@ -75,12 +69,10 @@ def list(self, country: Optional[str] = None, **kwargs: Any) -> AsyncIterable["_ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServiceLocationListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringServiceLocationListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -91,16 +83,14 @@ def list(self, country: Optional[str] = None, **kwargs: Any) -> AsyncIterable["_ def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( subscription_id=self._config.subscription_id, country=country, api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -112,26 +102,26 @@ 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) # type: ignore - 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("PeeringServiceLocationListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -143,5 +133,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peeringServiceLocations"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_service_providers_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_service_providers_operations.py index d019aa90c885..f0a371089d49 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_service_providers_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_service_providers_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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, @@ -20,21 +20,16 @@ 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 ..._utils.serialization import Deserializer, Serializer from ...operations._peering_service_providers_operations import build_list_request -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -53,16 +48,15 @@ class PeeringServiceProvidersOperations: 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: PeeringManagementClientConfiguration = 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.PeeringServiceProvider"]: """Lists all of the available peering service locations for the specified kind of peering. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringServiceProvider or the result of cls(response) :rtype: @@ -72,12 +66,10 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.PeeringServiceProvider"] _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServiceProviderListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringServiceProviderListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -88,15 +80,13 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.PeeringServiceProvider"] def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -108,26 +98,26 @@ 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) # type: ignore - 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("PeeringServiceProviderListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -139,5 +129,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peeringServiceProviders"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_services_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_services_operations.py index 2c38500ae284..d9ecacaf77a4 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_services_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peering_services_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,12 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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 +21,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 ..._utils.serialization import Deserializer, Serializer from ...operations._peering_services_operations import ( build_create_or_update_request, build_delete_request, @@ -38,12 +38,8 @@ build_list_by_subscription_request, build_update_request, ) -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -62,10 +58,10 @@ class PeeringServicesOperations: 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: PeeringManagementClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace_async async def get(self, resource_group_name: str, peering_service_name: str, **kwargs: Any) -> _models.PeeringService: @@ -76,12 +72,11 @@ async def get(self, resource_group_name: str, peering_service_name: str, **kwarg :type resource_group_name: str :param peering_service_name: The name of the peering. Required. :type peering_service_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringService or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringService :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -92,25 +87,22 @@ async def get(self, resource_group_name: str, peering_service_name: str, **kwarg _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringService] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringService] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, peering_service_name=peering_service_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -120,14 +112,12 @@ async def get(self, resource_group_name: str, peering_service_name: str, **kwarg error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("PeeringService", pipeline_response) + deserialized = self._deserialize("PeeringService", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}"} # type: ignore + return deserialized # type: ignore @overload async def create_or_update( @@ -151,7 +141,6 @@ async def create_or_update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringService or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringService :raises ~azure.core.exceptions.HttpResponseError: @@ -162,7 +151,7 @@ async def create_or_update( self, resource_group_name: str, peering_service_name: str, - peering_service: IO, + peering_service: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -175,11 +164,10 @@ async def create_or_update( :param peering_service_name: The name of the peering service. Required. :type peering_service_name: str :param peering_service: The properties needed to create or update a peering service. Required. - :type peering_service: IO + :type peering_service: 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: PeeringService or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringService :raises ~azure.core.exceptions.HttpResponseError: @@ -190,7 +178,7 @@ async def create_or_update( self, resource_group_name: str, peering_service_name: str, - peering_service: Union[_models.PeeringService, IO], + peering_service: Union[_models.PeeringService, IO[bytes]], **kwargs: Any ) -> _models.PeeringService: """Creates a new peering service or updates an existing peering with the specified name under the @@ -201,17 +189,13 @@ async def create_or_update( :param peering_service_name: The name of the peering service. Required. :type peering_service_name: str :param peering_service: The properties needed to create or update a peering service. Is either - a model type or a IO type. Required. - :type peering_service: ~azure.mgmt.peering.models.PeeringService 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 + a PeeringService type or a IO[bytes] type. Required. + :type peering_service: ~azure.mgmt.peering.models.PeeringService or IO[bytes] :return: PeeringService or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringService :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -222,21 +206,19 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringService] + 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.PeeringService] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(peering_service, (IO, bytes)): + if isinstance(peering_service, (IOBase, bytes)): _content = peering_service else: _json = self._serialize.body(peering_service, "PeeringService") - request = build_create_or_update_request( + _request = build_create_or_update_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, subscription_id=self._config.subscription_id, @@ -244,15 +226,14 @@ async def create_or_update( content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -262,23 +243,15 @@ async def create_or_update( 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("PeeringService", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("PeeringService", pipeline_response) + deserialized = self._deserialize("PeeringService", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}"} # type: ignore + return deserialized # type: ignore @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, peering_service_name: str, **kwargs: Any - ) -> None: + async def delete(self, resource_group_name: str, peering_service_name: str, **kwargs: Any) -> None: """Deletes an existing peering service with the specified name under the given subscription and resource group. @@ -286,12 +259,11 @@ async def delete( # pylint: disable=inconsistent-return-statements :type resource_group_name: str :param peering_service_name: The name of the peering service. Required. :type peering_service_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, @@ -302,25 +274,22 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + 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, peering_service_name=peering_service_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -331,9 +300,7 @@ 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.Peering/peeringServices/{peeringServiceName}"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore @overload async def update( @@ -357,7 +324,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: PeeringService or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringService :raises ~azure.core.exceptions.HttpResponseError: @@ -368,7 +334,7 @@ async def update( self, resource_group_name: str, peering_service_name: str, - tags: IO, + tags: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -381,11 +347,10 @@ async def update( :param peering_service_name: The name of the peering service. Required. :type peering_service_name: str :param tags: The resource tags. Required. - :type tags: IO + :type tags: 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: PeeringService or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringService :raises ~azure.core.exceptions.HttpResponseError: @@ -393,7 +358,11 @@ async def update( @distributed_trace_async async def update( - self, resource_group_name: str, peering_service_name: str, tags: Union[_models.ResourceTags, IO], **kwargs: Any + self, + resource_group_name: str, + peering_service_name: str, + tags: Union[_models.ResourceTags, IO[bytes]], + **kwargs: Any ) -> _models.PeeringService: """Updates tags for a peering service with the specified name under the given subscription and resource group. @@ -402,17 +371,13 @@ async def update( :type resource_group_name: str :param peering_service_name: The name of the peering service. Required. :type peering_service_name: str - :param tags: The resource tags. Is either a model type or a IO type. Required. - :type tags: ~azure.mgmt.peering.models.ResourceTags 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 tags: The resource tags. Is either a ResourceTags type or a IO[bytes] type. Required. + :type tags: ~azure.mgmt.peering.models.ResourceTags or IO[bytes] :return: PeeringService or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringService :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -423,21 +388,19 @@ async def update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringService] + 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.PeeringService] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(tags, (IO, bytes)): + if isinstance(tags, (IOBase, bytes)): _content = tags else: _json = self._serialize.body(tags, "ResourceTags") - request = build_update_request( + _request = build_update_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, subscription_id=self._config.subscription_id, @@ -445,15 +408,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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -463,14 +425,12 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("PeeringService", pipeline_response) + deserialized = self._deserialize("PeeringService", 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.Peering/peeringServices/{peeringServiceName}"} # type: ignore + return deserialized # type: ignore @distributed_trace def list_by_resource_group( @@ -480,7 +440,6 @@ def list_by_resource_group( :param resource_group_name: The name of the resource group. 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 PeeringService or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.peering.models.PeeringService] :raises ~azure.core.exceptions.HttpResponseError: @@ -488,12 +447,10 @@ def list_by_resource_group( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServiceListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringServiceListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -504,16 +461,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) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -525,26 +480,26 @@ 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) # type: ignore - 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("PeeringServiceListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -557,13 +512,10 @@ 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.Peering/peeringServices"} # type: ignore - @distributed_trace def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.PeeringService"]: """Lists all of the peerings under the given subscription. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringService or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.peering.models.PeeringService] :raises ~azure.core.exceptions.HttpResponseError: @@ -571,12 +523,10 @@ def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.PeeringS _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServiceListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringServiceListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -587,15 +537,13 @@ def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.PeeringS 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) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -607,26 +555,26 @@ 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) # type: ignore - 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("PeeringServiceListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -639,20 +587,15 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peeringServices"} # type: ignore - @distributed_trace_async - async def initialize_connection_monitor( # pylint: disable=inconsistent-return-statements - self, **kwargs: Any - ) -> None: + async def initialize_connection_monitor(self, **kwargs: Any) -> None: """Initialize Peering Service for Connection Monitor functionality. - :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, @@ -663,23 +606,20 @@ async def initialize_connection_monitor( # pylint: disable=inconsistent-return- _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[None] = kwargs.pop("cls", None) - request = build_initialize_connection_monitor_request( + _request = build_initialize_connection_monitor_request( subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.initialize_connection_monitor.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -690,6 +630,4 @@ async def initialize_connection_monitor( # pylint: disable=inconsistent-return- raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: - return cls(pipeline_response, None, {}) - - initialize_connection_monitor.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/initializeConnectionMonitor"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peerings_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peerings_operations.py index a71b7460d495..60754f471b4f 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peerings_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_peerings_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,12 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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 +21,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 ..._utils.serialization import Deserializer, Serializer from ...operations._peerings_operations import ( build_create_or_update_request, build_delete_request, @@ -37,12 +37,8 @@ build_list_by_subscription_request, build_update_request, ) -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -61,10 +57,10 @@ class PeeringsOperations: 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: PeeringManagementClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace_async async def get(self, resource_group_name: str, peering_name: str, **kwargs: Any) -> _models.Peering: @@ -75,12 +71,11 @@ async def get(self, resource_group_name: str, peering_name: str, **kwargs: Any) :type resource_group_name: str :param peering_name: The name of the peering. Required. :type peering_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: Peering or the result of cls(response) :rtype: ~azure.mgmt.peering.models.Peering :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -91,25 +86,22 @@ async def get(self, resource_group_name: str, peering_name: str, **kwargs: Any) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.Peering] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.Peering] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, peering_name=peering_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -119,14 +111,12 @@ async def get(self, resource_group_name: str, peering_name: str, **kwargs: Any) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("Peering", pipeline_response) + deserialized = self._deserialize("Peering", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}"} # type: ignore + return deserialized # type: ignore @overload async def create_or_update( @@ -150,7 +140,6 @@ async def create_or_update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: Peering or the result of cls(response) :rtype: ~azure.mgmt.peering.models.Peering :raises ~azure.core.exceptions.HttpResponseError: @@ -161,7 +150,7 @@ async def create_or_update( self, resource_group_name: str, peering_name: str, - peering: IO, + peering: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -174,11 +163,10 @@ async def create_or_update( :param peering_name: The name of the peering. Required. :type peering_name: str :param peering: The properties needed to create or update a peering. Required. - :type peering: IO + :type peering: 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: Peering or the result of cls(response) :rtype: ~azure.mgmt.peering.models.Peering :raises ~azure.core.exceptions.HttpResponseError: @@ -186,7 +174,7 @@ async def create_or_update( @distributed_trace_async async def create_or_update( - self, resource_group_name: str, peering_name: str, peering: Union[_models.Peering, IO], **kwargs: Any + self, resource_group_name: str, peering_name: str, peering: Union[_models.Peering, IO[bytes]], **kwargs: Any ) -> _models.Peering: """Creates a new peering or updates an existing peering with the specified name under the given subscription and resource group. @@ -195,18 +183,14 @@ async def create_or_update( :type resource_group_name: str :param peering_name: The name of the peering. Required. :type peering_name: str - :param peering: The properties needed to create or update a peering. Is either a model type or - a IO type. Required. - :type peering: ~azure.mgmt.peering.models.Peering 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 peering: The properties needed to create or update a peering. Is either a Peering type + or a IO[bytes] type. Required. + :type peering: ~azure.mgmt.peering.models.Peering or IO[bytes] :return: Peering or the result of cls(response) :rtype: ~azure.mgmt.peering.models.Peering :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -217,21 +201,19 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.Peering] + 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.Peering] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(peering, (IO, bytes)): + if isinstance(peering, (IOBase, bytes)): _content = peering else: _json = self._serialize.body(peering, "Peering") - request = build_create_or_update_request( + _request = build_create_or_update_request( resource_group_name=resource_group_name, peering_name=peering_name, subscription_id=self._config.subscription_id, @@ -239,15 +221,14 @@ async def create_or_update( content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -257,23 +238,15 @@ async def create_or_update( 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("Peering", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("Peering", pipeline_response) + deserialized = self._deserialize("Peering", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}"} # type: ignore + return deserialized # type: ignore @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements - self, resource_group_name: str, peering_name: str, **kwargs: Any - ) -> None: + async def delete(self, resource_group_name: str, peering_name: str, **kwargs: Any) -> None: """Deletes an existing peering with the specified name under the given subscription and resource group. @@ -281,12 +254,11 @@ async def delete( # pylint: disable=inconsistent-return-statements :type resource_group_name: str :param peering_name: The name of the peering. Required. :type peering_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, @@ -297,25 +269,22 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + 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, peering_name=peering_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -326,9 +295,7 @@ 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.Peering/peerings/{peeringName}"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore @overload async def update( @@ -352,7 +319,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: Peering or the result of cls(response) :rtype: ~azure.mgmt.peering.models.Peering :raises ~azure.core.exceptions.HttpResponseError: @@ -363,7 +329,7 @@ async def update( self, resource_group_name: str, peering_name: str, - tags: IO, + tags: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -376,11 +342,10 @@ async def update( :param peering_name: The name of the peering. Required. :type peering_name: str :param tags: The resource tags. Required. - :type tags: IO + :type tags: 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: Peering or the result of cls(response) :rtype: ~azure.mgmt.peering.models.Peering :raises ~azure.core.exceptions.HttpResponseError: @@ -388,7 +353,7 @@ async def update( @distributed_trace_async async def update( - self, resource_group_name: str, peering_name: str, tags: Union[_models.ResourceTags, IO], **kwargs: Any + self, resource_group_name: str, peering_name: str, tags: Union[_models.ResourceTags, IO[bytes]], **kwargs: Any ) -> _models.Peering: """Updates tags for a peering with the specified name under the given subscription and resource group. @@ -397,17 +362,13 @@ async def update( :type resource_group_name: str :param peering_name: The name of the peering. Required. :type peering_name: str - :param tags: The resource tags. Is either a model type or a IO type. Required. - :type tags: ~azure.mgmt.peering.models.ResourceTags 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 tags: The resource tags. Is either a ResourceTags type or a IO[bytes] type. Required. + :type tags: ~azure.mgmt.peering.models.ResourceTags or IO[bytes] :return: Peering or the result of cls(response) :rtype: ~azure.mgmt.peering.models.Peering :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -418,21 +379,19 @@ async def update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.Peering] + 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.Peering] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(tags, (IO, bytes)): + if isinstance(tags, (IOBase, bytes)): _content = tags else: _json = self._serialize.body(tags, "ResourceTags") - request = build_update_request( + _request = build_update_request( resource_group_name=resource_group_name, peering_name=peering_name, subscription_id=self._config.subscription_id, @@ -440,15 +399,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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -458,14 +416,12 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("Peering", pipeline_response) + deserialized = self._deserialize("Peering", 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.Peering/peerings/{peeringName}"} # type: ignore + return deserialized # type: ignore @distributed_trace def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> AsyncIterable["_models.Peering"]: @@ -473,7 +429,6 @@ def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Asy :param resource_group_name: The name of the resource group. 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 Peering or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.peering.models.Peering] :raises ~azure.core.exceptions.HttpResponseError: @@ -481,12 +436,10 @@ def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Asy _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -497,16 +450,14 @@ def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Asy def prepare_request(next_link=None): if not next_link: - request = build_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) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -518,26 +469,26 @@ 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) # type: ignore - 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("PeeringListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -550,13 +501,10 @@ 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.Peering/peerings"} # type: ignore - @distributed_trace def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.Peering"]: """Lists all of the peerings under the given subscription. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either Peering or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.peering.models.Peering] :raises ~azure.core.exceptions.HttpResponseError: @@ -564,12 +512,10 @@ def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.Peering" _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -580,15 +526,13 @@ def list_by_subscription(self, **kwargs: Any) -> AsyncIterable["_models.Peering" 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) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -600,26 +544,26 @@ 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) # type: ignore - 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("PeeringListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -631,5 +575,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peerings"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_prefixes_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_prefixes_operations.py index 1ca05642f1a6..e2023cd0b938 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_prefixes_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_prefixes_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,12 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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,27 +21,22 @@ 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 ..._utils.serialization import Deserializer, Serializer from ...operations._prefixes_operations import ( build_create_or_update_request, build_delete_request, build_get_request, build_list_by_peering_service_request, ) -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -59,10 +55,10 @@ class PrefixesOperations: 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: PeeringManagementClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace_async async def get( @@ -84,12 +80,11 @@ async def get( :type prefix_name: str :param expand: The properties to be expanded. Default value is None. :type expand: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringServicePrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringServicePrefix :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -100,27 +95,24 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServicePrefix] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringServicePrefix] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, prefix_name=prefix_name, subscription_id=self._config.subscription_id, expand=expand, api_version=api_version, - template_url=self.get.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -130,14 +122,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("PeeringServicePrefix", pipeline_response) + deserialized = self._deserialize("PeeringServicePrefix", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/prefixes/{prefixName}"} # type: ignore + return deserialized # type: ignore @overload async def create_or_update( @@ -164,7 +154,6 @@ async def create_or_update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringServicePrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringServicePrefix :raises ~azure.core.exceptions.HttpResponseError: @@ -176,7 +165,7 @@ async def create_or_update( resource_group_name: str, peering_service_name: str, prefix_name: str, - peering_service_prefix: IO, + peering_service_prefix: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -191,11 +180,10 @@ async def create_or_update( :param prefix_name: The name of the prefix. Required. :type prefix_name: str :param peering_service_prefix: The properties needed to create a prefix. Required. - :type peering_service_prefix: IO + :type peering_service_prefix: 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: PeeringServicePrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringServicePrefix :raises ~azure.core.exceptions.HttpResponseError: @@ -207,7 +195,7 @@ async def create_or_update( resource_group_name: str, peering_service_name: str, prefix_name: str, - peering_service_prefix: Union[_models.PeeringServicePrefix, IO], + peering_service_prefix: Union[_models.PeeringServicePrefix, IO[bytes]], **kwargs: Any ) -> _models.PeeringServicePrefix: """Creates a new prefix with the specified name under the given subscription, resource group and @@ -219,18 +207,14 @@ async def create_or_update( :type peering_service_name: str :param prefix_name: The name of the prefix. Required. :type prefix_name: str - :param peering_service_prefix: The properties needed to create a prefix. Is either a model type - or a IO type. Required. - :type peering_service_prefix: ~azure.mgmt.peering.models.PeeringServicePrefix 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 peering_service_prefix: The properties needed to create a prefix. Is either a + PeeringServicePrefix type or a IO[bytes] type. Required. + :type peering_service_prefix: ~azure.mgmt.peering.models.PeeringServicePrefix or IO[bytes] :return: PeeringServicePrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringServicePrefix :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -241,21 +225,19 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServicePrefix] + 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.PeeringServicePrefix] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(peering_service_prefix, (IO, bytes)): + if isinstance(peering_service_prefix, (IOBase, bytes)): _content = peering_service_prefix else: _json = self._serialize.body(peering_service_prefix, "PeeringServicePrefix") - request = build_create_or_update_request( + _request = build_create_or_update_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, prefix_name=prefix_name, @@ -264,15 +246,14 @@ async def create_or_update( content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -282,21 +263,15 @@ async def create_or_update( 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("PeeringServicePrefix", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("PeeringServicePrefix", pipeline_response) + deserialized = self._deserialize("PeeringServicePrefix", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/prefixes/{prefixName}"} # type: ignore + return deserialized # type: ignore @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements + async def delete( self, resource_group_name: str, peering_service_name: str, prefix_name: str, **kwargs: Any ) -> None: """Deletes an existing prefix with the specified name under the given subscription, resource group @@ -308,12 +283,11 @@ async def delete( # pylint: disable=inconsistent-return-statements :type peering_service_name: str :param prefix_name: The name of the prefix. Required. :type prefix_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, @@ -324,26 +298,23 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + 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, peering_service_name=peering_service_name, prefix_name=prefix_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -354,9 +325,7 @@ 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.Peering/peeringServices/{peeringServiceName}/prefixes/{prefixName}"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore @distributed_trace def list_by_peering_service( @@ -370,7 +339,6 @@ def list_by_peering_service( :type peering_service_name: str :param expand: The properties to be expanded. Default value is None. :type expand: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringServicePrefix or the result of cls(response) :rtype: @@ -380,12 +348,10 @@ def list_by_peering_service( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServicePrefixListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringServicePrefixListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -396,18 +362,16 @@ def list_by_peering_service( def prepare_request(next_link=None): if not next_link: - request = build_list_by_peering_service_request( + _request = build_list_by_peering_service_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, subscription_id=self._config.subscription_id, expand=expand, api_version=api_version, - template_url=self.list_by_peering_service.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -419,26 +383,26 @@ 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) # type: ignore - 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("PeeringServicePrefixListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -450,5 +414,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list_by_peering_service.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/prefixes"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_received_routes_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_received_routes_operations.py index 8e60064e3871..053f7167d23e 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_received_routes_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_received_routes_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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, @@ -20,21 +20,16 @@ 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 ..._utils.serialization import Deserializer, Serializer from ...operations._received_routes_operations import build_list_by_peering_request -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -53,10 +48,10 @@ class ReceivedRoutesOperations: 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: PeeringManagementClientConfiguration = 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_peering( @@ -92,7 +87,6 @@ def list_by_peering( :param skip_token: The optional page continuation token that is used in the event of paginated result. Default value is None. :type skip_token: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringReceivedRoute or the result of cls(response) :rtype: @@ -102,12 +96,10 @@ def list_by_peering( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringReceivedRouteListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringReceivedRouteListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -118,7 +110,7 @@ def list_by_peering( def prepare_request(next_link=None): if not next_link: - request = build_list_by_peering_request( + _request = build_list_by_peering_request( resource_group_name=resource_group_name, peering_name=peering_name, subscription_id=self._config.subscription_id, @@ -128,12 +120,10 @@ def prepare_request(next_link=None): rpki_validation_state=rpki_validation_state, skip_token=skip_token, api_version=api_version, - template_url=self.list_by_peering.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -145,26 +135,26 @@ 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) # type: ignore - 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("PeeringReceivedRouteListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -176,5 +166,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list_by_peering.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/receivedRoutes"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_registered_asns_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_registered_asns_operations.py index c06e4dee0001..3aed49e51c5b 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_registered_asns_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_registered_asns_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,12 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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,27 +21,22 @@ 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 ..._utils.serialization import Deserializer, Serializer from ...operations._registered_asns_operations import ( build_create_or_update_request, build_delete_request, build_get_request, build_list_by_peering_request, ) -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -59,10 +55,10 @@ class RegisteredAsnsOperations: 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: PeeringManagementClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace_async async def get( @@ -77,12 +73,11 @@ async def get( :type peering_name: str :param registered_asn_name: The name of the registered ASN. Required. :type registered_asn_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringRegisteredAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredAsn :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -93,26 +88,23 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringRegisteredAsn] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringRegisteredAsn] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, peering_name=peering_name, registered_asn_name=registered_asn_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -122,14 +114,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("PeeringRegisteredAsn", pipeline_response) + deserialized = self._deserialize("PeeringRegisteredAsn", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredAsns/{registeredAsnName}"} # type: ignore + return deserialized # type: ignore @overload async def create_or_update( @@ -156,7 +146,6 @@ async def create_or_update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringRegisteredAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredAsn :raises ~azure.core.exceptions.HttpResponseError: @@ -168,7 +157,7 @@ async def create_or_update( resource_group_name: str, peering_name: str, registered_asn_name: str, - registered_asn: IO, + registered_asn: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -183,11 +172,10 @@ async def create_or_update( :param registered_asn_name: The name of the ASN. Required. :type registered_asn_name: str :param registered_asn: The properties needed to create a registered ASN. Required. - :type registered_asn: IO + :type registered_asn: 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: PeeringRegisteredAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredAsn :raises ~azure.core.exceptions.HttpResponseError: @@ -199,7 +187,7 @@ async def create_or_update( resource_group_name: str, peering_name: str, registered_asn_name: str, - registered_asn: Union[_models.PeeringRegisteredAsn, IO], + registered_asn: Union[_models.PeeringRegisteredAsn, IO[bytes]], **kwargs: Any ) -> _models.PeeringRegisteredAsn: """Creates a new registered ASN with the specified name under the given subscription, resource @@ -211,18 +199,14 @@ async def create_or_update( :type peering_name: str :param registered_asn_name: The name of the ASN. Required. :type registered_asn_name: str - :param registered_asn: The properties needed to create a registered ASN. Is either a model type - or a IO type. Required. - :type registered_asn: ~azure.mgmt.peering.models.PeeringRegisteredAsn 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 registered_asn: The properties needed to create a registered ASN. Is either a + PeeringRegisteredAsn type or a IO[bytes] type. Required. + :type registered_asn: ~azure.mgmt.peering.models.PeeringRegisteredAsn or IO[bytes] :return: PeeringRegisteredAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredAsn :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -233,21 +217,19 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringRegisteredAsn] + 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.PeeringRegisteredAsn] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(registered_asn, (IO, bytes)): + if isinstance(registered_asn, (IOBase, bytes)): _content = registered_asn else: _json = self._serialize.body(registered_asn, "PeeringRegisteredAsn") - request = build_create_or_update_request( + _request = build_create_or_update_request( resource_group_name=resource_group_name, peering_name=peering_name, registered_asn_name=registered_asn_name, @@ -256,15 +238,14 @@ async def create_or_update( content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -274,21 +255,15 @@ async def create_or_update( 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("PeeringRegisteredAsn", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("PeeringRegisteredAsn", pipeline_response) + deserialized = self._deserialize("PeeringRegisteredAsn", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredAsns/{registeredAsnName}"} # type: ignore + return deserialized # type: ignore @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements + async def delete( self, resource_group_name: str, peering_name: str, registered_asn_name: str, **kwargs: Any ) -> None: """Deletes an existing registered ASN with the specified name under the given subscription, @@ -300,12 +275,11 @@ async def delete( # pylint: disable=inconsistent-return-statements :type peering_name: str :param registered_asn_name: The name of the registered ASN. Required. :type registered_asn_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, @@ -316,26 +290,23 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + 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, peering_name=peering_name, registered_asn_name=registered_asn_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -346,9 +317,7 @@ 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.Peering/peerings/{peeringName}/registeredAsns/{registeredAsnName}"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore @distributed_trace def list_by_peering( @@ -360,7 +329,6 @@ def list_by_peering( :type resource_group_name: str :param peering_name: The name of the peering. Required. :type peering_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringRegisteredAsn or the result of cls(response) :rtype: @@ -370,12 +338,10 @@ def list_by_peering( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringRegisteredAsnListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringRegisteredAsnListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -386,17 +352,15 @@ def list_by_peering( def prepare_request(next_link=None): if not next_link: - request = build_list_by_peering_request( + _request = build_list_by_peering_request( resource_group_name=resource_group_name, peering_name=peering_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_peering.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -408,26 +372,26 @@ 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) # type: ignore - 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("PeeringRegisteredAsnListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -439,5 +403,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list_by_peering.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredAsns"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_registered_prefixes_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_registered_prefixes_operations.py index 2dd0e3ecd6dc..cc2102bd60d5 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_registered_prefixes_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_registered_prefixes_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,12 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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 +21,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 ..._utils.serialization import Deserializer, Serializer from ...operations._registered_prefixes_operations import ( build_create_or_update_request, build_delete_request, @@ -36,12 +36,8 @@ build_list_by_peering_request, build_validate_request, ) -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -60,10 +56,10 @@ class RegisteredPrefixesOperations: 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: PeeringManagementClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace_async async def get( @@ -78,12 +74,11 @@ async def get( :type peering_name: str :param registered_prefix_name: The name of the registered prefix. Required. :type registered_prefix_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringRegisteredPrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredPrefix :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -94,26 +89,23 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringRegisteredPrefix] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringRegisteredPrefix] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, peering_name=peering_name, registered_prefix_name=registered_prefix_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -123,14 +115,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("PeeringRegisteredPrefix", pipeline_response) + deserialized = self._deserialize("PeeringRegisteredPrefix", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredPrefixes/{registeredPrefixName}"} # type: ignore + return deserialized # type: ignore @overload async def create_or_update( @@ -157,7 +147,6 @@ async def create_or_update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringRegisteredPrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredPrefix :raises ~azure.core.exceptions.HttpResponseError: @@ -169,7 +158,7 @@ async def create_or_update( resource_group_name: str, peering_name: str, registered_prefix_name: str, - registered_prefix: IO, + registered_prefix: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -184,11 +173,10 @@ async def create_or_update( :param registered_prefix_name: The name of the registered prefix. Required. :type registered_prefix_name: str :param registered_prefix: The properties needed to create a registered prefix. Required. - :type registered_prefix: IO + :type registered_prefix: 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: PeeringRegisteredPrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredPrefix :raises ~azure.core.exceptions.HttpResponseError: @@ -200,7 +188,7 @@ async def create_or_update( resource_group_name: str, peering_name: str, registered_prefix_name: str, - registered_prefix: Union[_models.PeeringRegisteredPrefix, IO], + registered_prefix: Union[_models.PeeringRegisteredPrefix, IO[bytes]], **kwargs: Any ) -> _models.PeeringRegisteredPrefix: """Creates a new registered prefix with the specified name under the given subscription, resource @@ -213,17 +201,13 @@ async def create_or_update( :param registered_prefix_name: The name of the registered prefix. Required. :type registered_prefix_name: str :param registered_prefix: The properties needed to create a registered prefix. Is either a - model type or a IO type. Required. - :type registered_prefix: ~azure.mgmt.peering.models.PeeringRegisteredPrefix 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 + PeeringRegisteredPrefix type or a IO[bytes] type. Required. + :type registered_prefix: ~azure.mgmt.peering.models.PeeringRegisteredPrefix or IO[bytes] :return: PeeringRegisteredPrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredPrefix :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -234,21 +218,19 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringRegisteredPrefix] + 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.PeeringRegisteredPrefix] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(registered_prefix, (IO, bytes)): + if isinstance(registered_prefix, (IOBase, bytes)): _content = registered_prefix else: _json = self._serialize.body(registered_prefix, "PeeringRegisteredPrefix") - request = build_create_or_update_request( + _request = build_create_or_update_request( resource_group_name=resource_group_name, peering_name=peering_name, registered_prefix_name=registered_prefix_name, @@ -257,15 +239,14 @@ async def create_or_update( content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -275,21 +256,15 @@ async def create_or_update( 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("PeeringRegisteredPrefix", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("PeeringRegisteredPrefix", pipeline_response) + deserialized = self._deserialize("PeeringRegisteredPrefix", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredPrefixes/{registeredPrefixName}"} # type: ignore + return deserialized # type: ignore @distributed_trace_async - async def delete( # pylint: disable=inconsistent-return-statements + async def delete( self, resource_group_name: str, peering_name: str, registered_prefix_name: str, **kwargs: Any ) -> None: """Deletes an existing registered prefix with the specified name under the given subscription, @@ -301,12 +276,11 @@ async def delete( # pylint: disable=inconsistent-return-statements :type peering_name: str :param registered_prefix_name: The name of the registered prefix. Required. :type registered_prefix_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, @@ -317,26 +291,23 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + 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, peering_name=peering_name, registered_prefix_name=registered_prefix_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -347,9 +318,7 @@ 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.Peering/peerings/{peeringName}/registeredPrefixes/{registeredPrefixName}"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore @distributed_trace def list_by_peering( @@ -361,7 +330,6 @@ def list_by_peering( :type resource_group_name: str :param peering_name: The name of the peering. Required. :type peering_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringRegisteredPrefix or the result of cls(response) :rtype: @@ -371,12 +339,10 @@ def list_by_peering( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringRegisteredPrefixListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringRegisteredPrefixListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -387,17 +353,15 @@ def list_by_peering( def prepare_request(next_link=None): if not next_link: - request = build_list_by_peering_request( + _request = build_list_by_peering_request( resource_group_name=resource_group_name, peering_name=peering_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_peering.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -409,26 +373,26 @@ 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) # type: ignore - 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("PeeringRegisteredPrefixListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -441,8 +405,6 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_peering.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredPrefixes"} # type: ignore - @distributed_trace_async async def validate( self, resource_group_name: str, peering_name: str, registered_prefix_name: str, **kwargs: Any @@ -456,12 +418,11 @@ async def validate( :type peering_name: str :param registered_prefix_name: The name of the registered prefix. Required. :type registered_prefix_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringRegisteredPrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredPrefix :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -472,26 +433,23 @@ async def validate( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringRegisteredPrefix] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringRegisteredPrefix] = kwargs.pop("cls", None) - request = build_validate_request( + _request = build_validate_request( resource_group_name=resource_group_name, peering_name=peering_name, registered_prefix_name=registered_prefix_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.validate.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -501,11 +459,9 @@ async def validate( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("PeeringRegisteredPrefix", pipeline_response) + deserialized = self._deserialize("PeeringRegisteredPrefix", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - validate.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredPrefixes/{registeredPrefixName}/validate"} # type: ignore + return deserialized # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_rp_unbilled_prefixes_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_rp_unbilled_prefixes_operations.py index 42d17dac52ee..1b0cecdb76ce 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_rp_unbilled_prefixes_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/aio/operations/_rp_unbilled_prefixes_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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, @@ -20,21 +20,16 @@ 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 ..._utils.serialization import Deserializer, Serializer from ...operations._rp_unbilled_prefixes_operations import build_list_request -from .._vendor import PeeringManagementClientMixinABC +from .._configuration import PeeringManagementClientConfiguration -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] @@ -53,10 +48,10 @@ class RpUnbilledPrefixesOperations: 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: PeeringManagementClientConfiguration = 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( @@ -70,7 +65,6 @@ def list( :type peering_name: str :param consolidate: Flag to enable consolidation prefixes. Default value is None. :type consolidate: bool - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either RpUnbilledPrefix or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.peering.models.RpUnbilledPrefix] :raises ~azure.core.exceptions.HttpResponseError: @@ -78,12 +72,10 @@ def list( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.RpUnbilledPrefixListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.RpUnbilledPrefixListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -94,18 +86,16 @@ def list( def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( resource_group_name=resource_group_name, peering_name=peering_name, subscription_id=self._config.subscription_id, consolidate=consolidate, api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -117,26 +107,26 @@ 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) # type: ignore - 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("RpUnbilledPrefixListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -148,5 +138,3 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/rpUnbilledPrefixes"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/models/__init__.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/models/__init__.py index abe035c843d2..c992163915be 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/models/__init__.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/models/__init__.py @@ -5,87 +5,103 @@ # 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 BgpSession -from ._models_py3 import CdnPeeringPrefix -from ._models_py3 import CdnPeeringPrefixListResult -from ._models_py3 import CheckServiceProviderAvailabilityInput -from ._models_py3 import ConnectionMonitorTest -from ._models_py3 import ConnectionMonitorTestListResult -from ._models_py3 import ContactDetail -from ._models_py3 import DirectConnection -from ._models_py3 import DirectPeeringFacility -from ._models_py3 import ErrorDetail -from ._models_py3 import ErrorResponse -from ._models_py3 import ExchangeConnection -from ._models_py3 import ExchangePeeringFacility -from ._models_py3 import LogAnalyticsWorkspaceProperties -from ._models_py3 import LookingGlassOutput -from ._models_py3 import MetricDimension -from ._models_py3 import MetricSpecification -from ._models_py3 import Operation -from ._models_py3 import OperationDisplayInfo -from ._models_py3 import OperationListResult -from ._models_py3 import PeerAsn -from ._models_py3 import PeerAsnListResult -from ._models_py3 import Peering -from ._models_py3 import PeeringBandwidthOffer -from ._models_py3 import PeeringListResult -from ._models_py3 import PeeringLocation -from ._models_py3 import PeeringLocationListResult -from ._models_py3 import PeeringLocationPropertiesDirect -from ._models_py3 import PeeringLocationPropertiesExchange -from ._models_py3 import PeeringPropertiesDirect -from ._models_py3 import PeeringPropertiesExchange -from ._models_py3 import PeeringReceivedRoute -from ._models_py3 import PeeringReceivedRouteListResult -from ._models_py3 import PeeringRegisteredAsn -from ._models_py3 import PeeringRegisteredAsnListResult -from ._models_py3 import PeeringRegisteredPrefix -from ._models_py3 import PeeringRegisteredPrefixListResult -from ._models_py3 import PeeringService -from ._models_py3 import PeeringServiceCountry -from ._models_py3 import PeeringServiceCountryListResult -from ._models_py3 import PeeringServiceListResult -from ._models_py3 import PeeringServiceLocation -from ._models_py3 import PeeringServiceLocationListResult -from ._models_py3 import PeeringServicePrefix -from ._models_py3 import PeeringServicePrefixEvent -from ._models_py3 import PeeringServicePrefixListResult -from ._models_py3 import PeeringServiceProvider -from ._models_py3 import PeeringServiceProviderListResult -from ._models_py3 import PeeringServiceSku -from ._models_py3 import PeeringSku -from ._models_py3 import Resource -from ._models_py3 import ResourceTags -from ._models_py3 import RpUnbilledPrefix -from ._models_py3 import RpUnbilledPrefixListResult -from ._models_py3 import ServiceSpecification -from ._models_py3 import SubResource +from typing import TYPE_CHECKING -from ._peering_management_client_enums import Command -from ._peering_management_client_enums import ConnectionState -from ._peering_management_client_enums import DirectPeeringType -from ._peering_management_client_enums import Enum0 -from ._peering_management_client_enums import Family -from ._peering_management_client_enums import Kind -from ._peering_management_client_enums import LearnedType -from ._peering_management_client_enums import LegacyPeeringsKind -from ._peering_management_client_enums import LookingGlassCommand -from ._peering_management_client_enums import LookingGlassSourceType -from ._peering_management_client_enums import PeeringLocationsDirectPeeringType -from ._peering_management_client_enums import PeeringLocationsKind -from ._peering_management_client_enums import PrefixValidationState -from ._peering_management_client_enums import ProvisioningState -from ._peering_management_client_enums import Role -from ._peering_management_client_enums import SessionAddressProvider -from ._peering_management_client_enums import SessionStateV4 -from ._peering_management_client_enums import SessionStateV6 -from ._peering_management_client_enums import Size -from ._peering_management_client_enums import Tier -from ._peering_management_client_enums import ValidationState +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + + +from ._models_py3 import ( # type: ignore + BgpSession, + CdnPeeringPrefix, + CdnPeeringPrefixListResult, + CheckServiceProviderAvailabilityInput, + ConnectionMonitorTest, + ConnectionMonitorTestListResult, + ConnectivityProbe, + ContactDetail, + DirectConnection, + DirectPeeringFacility, + ErrorDetail, + ErrorResponse, + ExchangeConnection, + ExchangePeeringFacility, + LogAnalyticsWorkspaceProperties, + LookingGlassOutput, + MetricDimension, + MetricSpecification, + Operation, + OperationDisplayInfo, + OperationListResult, + PeerAsn, + PeerAsnListResult, + Peering, + PeeringBandwidthOffer, + PeeringListResult, + PeeringLocation, + PeeringLocationListResult, + PeeringLocationPropertiesDirect, + PeeringLocationPropertiesExchange, + PeeringPropertiesDirect, + PeeringPropertiesExchange, + PeeringReceivedRoute, + PeeringReceivedRouteListResult, + PeeringRegisteredAsn, + PeeringRegisteredAsnListResult, + PeeringRegisteredPrefix, + PeeringRegisteredPrefixListResult, + PeeringService, + PeeringServiceCountry, + PeeringServiceCountryListResult, + PeeringServiceListResult, + PeeringServiceLocation, + PeeringServiceLocationListResult, + PeeringServicePrefix, + PeeringServicePrefixEvent, + PeeringServicePrefixListResult, + PeeringServiceProvider, + PeeringServiceProviderListResult, + PeeringServiceSku, + PeeringSku, + Resource, + ResourceTags, + RpUnbilledPrefix, + RpUnbilledPrefixListResult, + ServiceSpecification, + SubResource, +) + +from ._peering_management_client_enums import ( # type: ignore + Command, + ConnectionState, + DirectPeeringType, + Enum0, + Enum11, + Enum13, + Family, + Kind, + LearnedType, + LegacyPeeringsKind, + LookingGlassCommand, + LookingGlassSourceType, + PeeringLocationsDirectPeeringType, + PeeringLocationsKind, + PrefixValidationState, + PreviousConnectionProvisioningState, + Protocol, + ProvisioningState, + Role, + SessionAddressProvider, + SessionStateV4, + SessionStateV6, + Size, + Tier, + ValidationState, +) from ._patch import __all__ as _patch_all -from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ @@ -95,6 +111,7 @@ "CheckServiceProviderAvailabilityInput", "ConnectionMonitorTest", "ConnectionMonitorTestListResult", + "ConnectivityProbe", "ContactDetail", "DirectConnection", "DirectPeeringFacility", @@ -149,6 +166,8 @@ "ConnectionState", "DirectPeeringType", "Enum0", + "Enum11", + "Enum13", "Family", "Kind", "LearnedType", @@ -158,6 +177,8 @@ "PeeringLocationsDirectPeeringType", "PeeringLocationsKind", "PrefixValidationState", + "PreviousConnectionProvisioningState", + "Protocol", "ProvisioningState", "Role", "SessionAddressProvider", @@ -167,5 +188,5 @@ "Tier", "ValidationState", ] -__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/peering/azure-mgmt-peering/azure/mgmt/peering/models/_models_py3.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/models/_models_py3.py index 83100b253ca4..999c6c7cad7c 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/models/_models_py3.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/models/_models_py3.py @@ -1,5 +1,5 @@ -# coding=utf-8 # pylint: disable=too-many-lines +# coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. @@ -7,16 +7,16 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Dict, List, Optional, TYPE_CHECKING, Union +import datetime +from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union -from .. import _serialization +from .._utils import serialization as _serialization if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports from .. import models as _models -class BgpSession(_serialization.Model): # pylint: disable=too-many-instance-attributes +class BgpSession(_serialization.Model): """The properties that define a BGP session. Variables are only populated by the server, and will be ignored when sending a request. @@ -82,8 +82,8 @@ def __init__( max_prefixes_advertised_v4: Optional[int] = None, max_prefixes_advertised_v6: Optional[int] = None, md5_authentication_key: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword session_prefix_v4: The IPv4 prefix that contains both ends' IPv4 addresses. :paramtype session_prefix_v4: str @@ -113,8 +113,8 @@ def __init__( self.microsoft_session_i_pv6_address = microsoft_session_i_pv6_address self.peer_session_i_pv4_address = peer_session_i_pv4_address self.peer_session_i_pv6_address = peer_session_i_pv6_address - self.session_state_v4 = None - self.session_state_v6 = None + self.session_state_v4: Optional[Union[str, "_models.SessionStateV4"]] = None + self.session_state_v6: Optional[Union[str, "_models.SessionStateV6"]] = None self.max_prefixes_advertised_v4 = max_prefixes_advertised_v4 self.max_prefixes_advertised_v6 = max_prefixes_advertised_v6 self.md5_authentication_key = md5_authentication_key @@ -145,12 +145,12 @@ class Resource(_serialization.Model): "type": {"key": "type", "type": "str"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.name = None - self.id = None - self.type = None + self.name: Optional[str] = None + self.id: Optional[str] = None + self.type: Optional[str] = None class CdnPeeringPrefix(Resource): @@ -198,14 +198,14 @@ class CdnPeeringPrefix(Resource): "bgp_community": {"key": "properties.bgpCommunity", "type": "str"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.prefix = None - self.azure_region = None - self.azure_service = None - self.is_primary_region = None - self.bgp_community = None + self.prefix: Optional[str] = None + self.azure_region: Optional[str] = None + self.azure_service: Optional[str] = None + self.is_primary_region: Optional[bool] = None + self.bgp_community: Optional[str] = None class CdnPeeringPrefixListResult(_serialization.Model): @@ -223,8 +223,12 @@ class CdnPeeringPrefixListResult(_serialization.Model): } def __init__( - self, *, value: Optional[List["_models.CdnPeeringPrefix"]] = None, next_link: Optional[str] = None, **kwargs - ): + self, + *, + value: Optional[List["_models.CdnPeeringPrefix"]] = None, + next_link: Optional[str] = None, + **kwargs: Any + ) -> None: """ :keyword value: The list of CDN peering prefixes. :paramtype value: list[~azure.mgmt.peering.models.CdnPeeringPrefix] @@ -255,8 +259,8 @@ def __init__( *, peering_service_location: Optional[str] = None, peering_service_provider: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword peering_service_location: Gets or sets the peering service location. :paramtype peering_service_location: str @@ -326,8 +330,8 @@ def __init__( destination: Optional[str] = None, destination_port: Optional[int] = None, test_frequency_in_sec: Optional[int] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword source_agent: The Connection Monitor test source agent. :paramtype source_agent: str @@ -343,9 +347,9 @@ def __init__( self.destination = destination self.destination_port = destination_port self.test_frequency_in_sec = test_frequency_in_sec - self.is_test_successful = None - self.path = None - self.provisioning_state = None + self.is_test_successful: Optional[bool] = None + self.path: Optional[List[str]] = None + self.provisioning_state: Optional[Union[str, "_models.ProvisioningState"]] = None class ConnectionMonitorTestListResult(_serialization.Model): @@ -367,8 +371,8 @@ def __init__( *, value: Optional[List["_models.ConnectionMonitorTest"]] = None, next_link: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword value: The list of Connection Monitor Tests. :paramtype value: list[~azure.mgmt.peering.models.ConnectionMonitorTest] @@ -380,6 +384,62 @@ def __init__( self.next_link = next_link +class ConnectivityProbe(_serialization.Model): + """Represents a connectivity probe, a configuration peers can add to direct and exchange peerings + to create ping tests. These ping + tests will allow us to generate availability, jitter, and latency data for traffic (using ICMP + or TCP) from Azure to an endpoint + IP address given by the customer. This data will be emitted such that the peer can view these + metrics in the Azure portal in the + Connectivity probe blade of their peering. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar endpoint: The endpoint IP address where traffic will be sent to from Azure. + :vartype endpoint: str + :ivar azure_region: The Azure region where traffic will originate from. + :vartype azure_region: str + :ivar protocol: The protocol of the traffic that will be sent. Known values are: "None", + "ICMP", and "TCP". + :vartype protocol: str or ~azure.mgmt.peering.models.Protocol + :ivar prefixes_to_accesslist: Set to contain the prefixes that agents in Azure will send + traffic from. For peers to allow into their + network the connectivity probe traffic can reach their endpoint. + :vartype prefixes_to_accesslist: list[str] + :ivar created_time_utc: Time when + {Microsoft.Peering.PeeringContract.Public.Data.ConnectivityProbe} was created in UTC. + :vartype created_time_utc: ~datetime.datetime + """ + + _validation = { + "endpoint": {"readonly": True}, + "azure_region": {"readonly": True}, + "protocol": {"readonly": True}, + "prefixes_to_accesslist": {"readonly": True}, + } + + _attribute_map = { + "endpoint": {"key": "endpoint", "type": "str"}, + "azure_region": {"key": "azureRegion", "type": "str"}, + "protocol": {"key": "protocol", "type": "str"}, + "prefixes_to_accesslist": {"key": "prefixesToAccesslist", "type": "[str]"}, + "created_time_utc": {"key": "createdTimeUtc", "type": "iso-8601"}, + } + + def __init__(self, *, created_time_utc: Optional[datetime.datetime] = None, **kwargs: Any) -> None: + """ + :keyword created_time_utc: Time when + {Microsoft.Peering.PeeringContract.Public.Data.ConnectivityProbe} was created in UTC. + :paramtype created_time_utc: ~datetime.datetime + """ + super().__init__(**kwargs) + self.endpoint: Optional[str] = None + self.azure_region: Optional[str] = None + self.protocol: Optional[Union[str, "_models.Protocol"]] = None + self.prefixes_to_accesslist: Optional[List[str]] = None + self.created_time_utc = created_time_utc + + class ContactDetail(_serialization.Model): """The contact detail class. @@ -404,8 +464,8 @@ def __init__( role: Optional[Union[str, "_models.Role"]] = None, email: Optional[str] = None, phone: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword role: The role of the contact. Known values are: "Noc", "Policy", "Technical", "Service", "Escalation", and "Other". @@ -444,15 +504,65 @@ class DirectConnection(_serialization.Model): :vartype peering_db_facility_id: int :ivar connection_state: The state of the connection. Known values are: "None", "PendingApproval", "Approved", "ProvisioningStarted", "ProvisioningFailed", - "ProvisioningCompleted", "Validating", "Active", "TypeChangeRequested", and - "TypeChangeInProgress". + "ProvisioningCompleted", "Validating", "Active", "TypeChangeRequested", "TypeChangeInProgress", + and "ExternalBlocker". :vartype connection_state: str or ~azure.mgmt.peering.models.ConnectionState :ivar bgp_session: The BGP session associated with the connection. :vartype bgp_session: ~azure.mgmt.peering.models.BgpSession + :ivar migration_work_window_bgp_session_same_device: The old V4 BGP session associated with the + connection during migration on the same device. Will be used for Work-Window validation. + :vartype migration_work_window_bgp_session_same_device: dict[str, str or + ~azure.mgmt.peering.models.Enum11] + :ivar last_failure_time_utc: Gets or sets the time corresponding to when the connection was + last set to ProvisioningFailed. + :vartype last_failure_time_utc: ~datetime.datetime :ivar connection_identifier: The unique identifier (GUID) for the connection. :vartype connection_identifier: str :ivar error_message: The error message related to the connection state, if any. :vartype error_message: str + :ivar previous_connection_provisioning_state: The previous connection provisioning state, used + to resume provisioning after connection has been blocked. Known values are: "None", + "InterconnectionPendingApproval", "DeviceStateValidation", "RocPendingApproval", + "AllocatePorts", "PortExhaustion", "CheckInterfaces", "EnableInterfaces", + "PhysicalConnectionSetup", "AwaitPairUpgrade", "LightCheck", "TestPing", "PingTestDone", + "AwaitPeerIps", "ValidateFltFirewall", "LagSetup", "AwaitLagCompletion", + "UpdateAddressesOnDevice", "FetchPrefixLimitFromPeeringDb", "BgpSessionConfiguration", + "NpmBgpSessionConfiguration", "Md5AuthKeyConfiguration", "FetchSessionState", "RemoveNomonit", + "UpdateApipaPrefixInSitepro", "ProvisioningCompleted", "PendingMigration", + "MigrationRequestPortAllocationRequested", "MigrationConfigValidation", + "PendingGlobalPolicyUpdate", "MigrationSpecificConfigDrift", "MigrationNpmError", + "PendingWorkWindow", "ExternalBlocker", "StaticMacConfiguration", "UndoMigrationGraphCleanup", + "MigrationWorkWindow", "PendingMigrationCompletion", "MigrationCompletionRequested", + "DirectPeeringTypeUpdateApproved", "DirectPeeringTypeUpdateRejected", + "DirectPeeringTypeUpdateIfDescription", "DirectPeeringTypeUpdatePrefixPrecheck", + "DirectPeeringTypeUpdateApplyDenyAll", "DirectPeeringTypeUpdateDeleteSession", + "DirectPeeringTypeUpdateLagAcl", "DirectPeeringTypeUpdateBgpConfig", + "DirectPeeringTypeUpdateFetchSessionState", "DirectPeeringTypeUpdateDeleteDenyAll", + "DirectPeeringTypeUpdatePrefixPostCheck", "DecomRocPendingApproval", "DecomAddDenyAll", + "DecomValidatePrefix", "DecomValidateTraffic", "DecomShutInterfaces", "DecomShutdownBgp", + "DecomCabling", "DecomRemoveBgpConfig", "DecomRemoveInterfaceConfig", "DecomGraphCleanup", + "DecomCompleted", "DirectPeeringTypeUpdateMd5AuthKeyConfiguration", "BfdConfiguration", + "DirectPeeringTypeUpdateBfdConfig", "DirectPeeringTypeUpdateMd5AuthKeyRead", + "PrefixListConfiguration", "WorkWindowCompleted", "FacilityMapValidation", + "DirectPeeringTypeUpdateReadMaxPrefixLimit", "DirectPeeringTypeUpdateUpdatePortWithNewIP", + "DirectPeeringTypeUpdateConfigureLagWithNewIP", "DirectPeeringTypeUpdateCleanupOldIPsfromLAG", + "MapsToMapsVoiceUpdateIfDescription", "MapsToMapsVoicePrefixPrecheck", + "MapsToMapsVoiceUpdateLAGAcl", "MapsToMapsVoiceConfigureBFD", + "MapsToMapsVoiceFetchSessionState", "MapsToMapsVoicePrefixPostCheck", + "BgpGroupChangeRocPendingApproval", "BgpGroupChangeWorkWindow", "IPChangeWorkWindow", + "PendingASNChangeApplyDenyALL", "PendingASNChangeUpdateNeighborConfig", + "PendingASNChangeRemoveDenyALL", "PendingASNChangeUpdateInterfaceDescription", + "UpdateGraphForASNChange", "UpdatePeeringForASNChange", "AddDenyAllRocPendingApproval", + "AwaitApplyDenyAll", "IPChangeValidation", "IPChangeCleanup", "ForcedIpChangeCleanup", + "ForcedIpChangeCleanupWithActiveSessions", "IPChangeInitiate", "IPChangeLag", + "IPChangeBgpUpdate", "IPChangeMd5Configuration", "IPChangeApplyDenyAll", + "IPChangeRemoveDenyAll", "IPChangeValidateSessions", "ACLConfiguration", and + "PendingSpecialWorkItem". + :vartype previous_connection_provisioning_state: str or + ~azure.mgmt.peering.models.PreviousConnectionProvisioningState + :ivar migration_work_window_tracker: Gets or sets the migration work window tracker. Format = + "DateTime String Format|WorkWindowInitiator Email ID". + :vartype migration_work_window_tracker: str """ _validation = { @@ -471,8 +581,15 @@ class DirectConnection(_serialization.Model): "peering_db_facility_id": {"key": "peeringDBFacilityId", "type": "int"}, "connection_state": {"key": "connectionState", "type": "str"}, "bgp_session": {"key": "bgpSession", "type": "BgpSession"}, + "migration_work_window_bgp_session_same_device": { + "key": "migrationWorkWindowBgpSessionSameDevice", + "type": "{str}", + }, + "last_failure_time_utc": {"key": "lastFailureTimeUtc", "type": "iso-8601"}, "connection_identifier": {"key": "connectionIdentifier", "type": "str"}, "error_message": {"key": "errorMessage", "type": "str"}, + "previous_connection_provisioning_state": {"key": "previousConnectionProvisioningState", "type": "str"}, + "migration_work_window_tracker": {"key": "migrationWorkWindowTracker", "type": "str"}, } def __init__( @@ -483,9 +600,15 @@ def __init__( use_for_peering_service: Optional[bool] = None, peering_db_facility_id: Optional[int] = None, bgp_session: Optional["_models.BgpSession"] = None, + migration_work_window_bgp_session_same_device: Optional[Dict[str, Union[str, "_models.Enum11"]]] = None, + last_failure_time_utc: Optional[datetime.datetime] = None, connection_identifier: Optional[str] = None, - **kwargs - ): + previous_connection_provisioning_state: Optional[ + Union[str, "_models.PreviousConnectionProvisioningState"] + ] = None, + migration_work_window_tracker: Optional[str] = None, + **kwargs: Any + ) -> None: """ :keyword bandwidth_in_mbps: The bandwidth of the connection. :paramtype bandwidth_in_mbps: int @@ -500,20 +623,74 @@ def __init__( :paramtype peering_db_facility_id: int :keyword bgp_session: The BGP session associated with the connection. :paramtype bgp_session: ~azure.mgmt.peering.models.BgpSession + :keyword migration_work_window_bgp_session_same_device: The old V4 BGP session associated with + the connection during migration on the same device. Will be used for Work-Window validation. + :paramtype migration_work_window_bgp_session_same_device: dict[str, str or + ~azure.mgmt.peering.models.Enum11] + :keyword last_failure_time_utc: Gets or sets the time corresponding to when the connection was + last set to ProvisioningFailed. + :paramtype last_failure_time_utc: ~datetime.datetime :keyword connection_identifier: The unique identifier (GUID) for the connection. :paramtype connection_identifier: str + :keyword previous_connection_provisioning_state: The previous connection provisioning state, + used to resume provisioning after connection has been blocked. Known values are: "None", + "InterconnectionPendingApproval", "DeviceStateValidation", "RocPendingApproval", + "AllocatePorts", "PortExhaustion", "CheckInterfaces", "EnableInterfaces", + "PhysicalConnectionSetup", "AwaitPairUpgrade", "LightCheck", "TestPing", "PingTestDone", + "AwaitPeerIps", "ValidateFltFirewall", "LagSetup", "AwaitLagCompletion", + "UpdateAddressesOnDevice", "FetchPrefixLimitFromPeeringDb", "BgpSessionConfiguration", + "NpmBgpSessionConfiguration", "Md5AuthKeyConfiguration", "FetchSessionState", "RemoveNomonit", + "UpdateApipaPrefixInSitepro", "ProvisioningCompleted", "PendingMigration", + "MigrationRequestPortAllocationRequested", "MigrationConfigValidation", + "PendingGlobalPolicyUpdate", "MigrationSpecificConfigDrift", "MigrationNpmError", + "PendingWorkWindow", "ExternalBlocker", "StaticMacConfiguration", "UndoMigrationGraphCleanup", + "MigrationWorkWindow", "PendingMigrationCompletion", "MigrationCompletionRequested", + "DirectPeeringTypeUpdateApproved", "DirectPeeringTypeUpdateRejected", + "DirectPeeringTypeUpdateIfDescription", "DirectPeeringTypeUpdatePrefixPrecheck", + "DirectPeeringTypeUpdateApplyDenyAll", "DirectPeeringTypeUpdateDeleteSession", + "DirectPeeringTypeUpdateLagAcl", "DirectPeeringTypeUpdateBgpConfig", + "DirectPeeringTypeUpdateFetchSessionState", "DirectPeeringTypeUpdateDeleteDenyAll", + "DirectPeeringTypeUpdatePrefixPostCheck", "DecomRocPendingApproval", "DecomAddDenyAll", + "DecomValidatePrefix", "DecomValidateTraffic", "DecomShutInterfaces", "DecomShutdownBgp", + "DecomCabling", "DecomRemoveBgpConfig", "DecomRemoveInterfaceConfig", "DecomGraphCleanup", + "DecomCompleted", "DirectPeeringTypeUpdateMd5AuthKeyConfiguration", "BfdConfiguration", + "DirectPeeringTypeUpdateBfdConfig", "DirectPeeringTypeUpdateMd5AuthKeyRead", + "PrefixListConfiguration", "WorkWindowCompleted", "FacilityMapValidation", + "DirectPeeringTypeUpdateReadMaxPrefixLimit", "DirectPeeringTypeUpdateUpdatePortWithNewIP", + "DirectPeeringTypeUpdateConfigureLagWithNewIP", "DirectPeeringTypeUpdateCleanupOldIPsfromLAG", + "MapsToMapsVoiceUpdateIfDescription", "MapsToMapsVoicePrefixPrecheck", + "MapsToMapsVoiceUpdateLAGAcl", "MapsToMapsVoiceConfigureBFD", + "MapsToMapsVoiceFetchSessionState", "MapsToMapsVoicePrefixPostCheck", + "BgpGroupChangeRocPendingApproval", "BgpGroupChangeWorkWindow", "IPChangeWorkWindow", + "PendingASNChangeApplyDenyALL", "PendingASNChangeUpdateNeighborConfig", + "PendingASNChangeRemoveDenyALL", "PendingASNChangeUpdateInterfaceDescription", + "UpdateGraphForASNChange", "UpdatePeeringForASNChange", "AddDenyAllRocPendingApproval", + "AwaitApplyDenyAll", "IPChangeValidation", "IPChangeCleanup", "ForcedIpChangeCleanup", + "ForcedIpChangeCleanupWithActiveSessions", "IPChangeInitiate", "IPChangeLag", + "IPChangeBgpUpdate", "IPChangeMd5Configuration", "IPChangeApplyDenyAll", + "IPChangeRemoveDenyAll", "IPChangeValidateSessions", "ACLConfiguration", and + "PendingSpecialWorkItem". + :paramtype previous_connection_provisioning_state: str or + ~azure.mgmt.peering.models.PreviousConnectionProvisioningState + :keyword migration_work_window_tracker: Gets or sets the migration work window tracker. Format + = "DateTime String Format|WorkWindowInitiator Email ID". + :paramtype migration_work_window_tracker: str """ super().__init__(**kwargs) self.bandwidth_in_mbps = bandwidth_in_mbps - self.provisioned_bandwidth_in_mbps = None + self.provisioned_bandwidth_in_mbps: Optional[int] = None self.session_address_provider = session_address_provider self.use_for_peering_service = use_for_peering_service - self.microsoft_tracking_id = None + self.microsoft_tracking_id: Optional[str] = None self.peering_db_facility_id = peering_db_facility_id - self.connection_state = None + self.connection_state: Optional[Union[str, "_models.ConnectionState"]] = None self.bgp_session = bgp_session + self.migration_work_window_bgp_session_same_device = migration_work_window_bgp_session_same_device + self.last_failure_time_utc = last_failure_time_utc self.connection_identifier = connection_identifier - self.error_message = None + self.error_message: Optional[str] = None + self.previous_connection_provisioning_state = previous_connection_provisioning_state + self.migration_work_window_tracker = migration_work_window_tracker class DirectPeeringFacility(_serialization.Model): @@ -522,7 +699,7 @@ class DirectPeeringFacility(_serialization.Model): :ivar address: The address of the direct peering facility. :vartype address: str :ivar direct_peering_type: The type of the direct peering. Known values are: "Edge", "Transit", - "Cdn", "Internal", "Ix", "IxRs", "Voice", and "EdgeZoneForOperators". + "Cdn", "Internal", "Ix", "IxRs", "Voice", "EdgeZoneForOperators", and "PeerProp". :vartype direct_peering_type: str or ~azure.mgmt.peering.models.DirectPeeringType :ivar peering_db_facility_id: The PeeringDB.com ID of the facility. :vartype peering_db_facility_id: int @@ -544,13 +721,13 @@ def __init__( direct_peering_type: Optional[Union[str, "_models.DirectPeeringType"]] = None, peering_db_facility_id: Optional[int] = None, peering_db_facility_link: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword address: The address of the direct peering facility. :paramtype address: str :keyword direct_peering_type: The type of the direct peering. Known values are: "Edge", - "Transit", "Cdn", "Internal", "Ix", "IxRs", "Voice", and "EdgeZoneForOperators". + "Transit", "Cdn", "Internal", "Ix", "IxRs", "Voice", "EdgeZoneForOperators", and "PeerProp". :paramtype direct_peering_type: str or ~azure.mgmt.peering.models.DirectPeeringType :keyword peering_db_facility_id: The PeeringDB.com ID of the facility. :paramtype peering_db_facility_id: int @@ -585,11 +762,11 @@ class ErrorDetail(_serialization.Model): "message": {"key": "message", "type": "str"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.code = None - self.message = None + self.code: Optional[str] = None + self.message: Optional[str] = None class ErrorResponse(_serialization.Model): @@ -603,7 +780,7 @@ class ErrorResponse(_serialization.Model): "error": {"key": "error", "type": "ErrorDetail"}, } - def __init__(self, *, error: Optional["_models.ErrorDetail"] = None, **kwargs): + def __init__(self, *, error: Optional["_models.ErrorDetail"] = None, **kwargs: Any) -> None: """ :keyword error: The error detail that describes why an operation has failed. :paramtype error: ~azure.mgmt.peering.models.ErrorDetail @@ -622,15 +799,65 @@ class ExchangeConnection(_serialization.Model): :vartype peering_db_facility_id: int :ivar connection_state: The state of the connection. Known values are: "None", "PendingApproval", "Approved", "ProvisioningStarted", "ProvisioningFailed", - "ProvisioningCompleted", "Validating", "Active", "TypeChangeRequested", and - "TypeChangeInProgress". + "ProvisioningCompleted", "Validating", "Active", "TypeChangeRequested", "TypeChangeInProgress", + and "ExternalBlocker". :vartype connection_state: str or ~azure.mgmt.peering.models.ConnectionState :ivar bgp_session: The BGP session associated with the connection. :vartype bgp_session: ~azure.mgmt.peering.models.BgpSession + :ivar migration_work_window_bgp_session_same_device: The old V4 BGP session associated with the + connection during migration on the same device. Will be used for Work-Window validation. + :vartype migration_work_window_bgp_session_same_device: dict[str, str or + ~azure.mgmt.peering.models.Enum13] + :ivar last_failure_time_utc: Gets or sets the time corresponding to when the connection was + last set to ProvisioningFailed. + :vartype last_failure_time_utc: ~datetime.datetime :ivar connection_identifier: The unique identifier (GUID) for the connection. :vartype connection_identifier: str :ivar error_message: The error message related to the connection state, if any. :vartype error_message: str + :ivar previous_connection_provisioning_state: The previous connection provisioning state, used + to resume provisioning after connection has been blocked. Known values are: "None", + "InterconnectionPendingApproval", "DeviceStateValidation", "RocPendingApproval", + "AllocatePorts", "PortExhaustion", "CheckInterfaces", "EnableInterfaces", + "PhysicalConnectionSetup", "AwaitPairUpgrade", "LightCheck", "TestPing", "PingTestDone", + "AwaitPeerIps", "ValidateFltFirewall", "LagSetup", "AwaitLagCompletion", + "UpdateAddressesOnDevice", "FetchPrefixLimitFromPeeringDb", "BgpSessionConfiguration", + "NpmBgpSessionConfiguration", "Md5AuthKeyConfiguration", "FetchSessionState", "RemoveNomonit", + "UpdateApipaPrefixInSitepro", "ProvisioningCompleted", "PendingMigration", + "MigrationRequestPortAllocationRequested", "MigrationConfigValidation", + "PendingGlobalPolicyUpdate", "MigrationSpecificConfigDrift", "MigrationNpmError", + "PendingWorkWindow", "ExternalBlocker", "StaticMacConfiguration", "UndoMigrationGraphCleanup", + "MigrationWorkWindow", "PendingMigrationCompletion", "MigrationCompletionRequested", + "DirectPeeringTypeUpdateApproved", "DirectPeeringTypeUpdateRejected", + "DirectPeeringTypeUpdateIfDescription", "DirectPeeringTypeUpdatePrefixPrecheck", + "DirectPeeringTypeUpdateApplyDenyAll", "DirectPeeringTypeUpdateDeleteSession", + "DirectPeeringTypeUpdateLagAcl", "DirectPeeringTypeUpdateBgpConfig", + "DirectPeeringTypeUpdateFetchSessionState", "DirectPeeringTypeUpdateDeleteDenyAll", + "DirectPeeringTypeUpdatePrefixPostCheck", "DecomRocPendingApproval", "DecomAddDenyAll", + "DecomValidatePrefix", "DecomValidateTraffic", "DecomShutInterfaces", "DecomShutdownBgp", + "DecomCabling", "DecomRemoveBgpConfig", "DecomRemoveInterfaceConfig", "DecomGraphCleanup", + "DecomCompleted", "DirectPeeringTypeUpdateMd5AuthKeyConfiguration", "BfdConfiguration", + "DirectPeeringTypeUpdateBfdConfig", "DirectPeeringTypeUpdateMd5AuthKeyRead", + "PrefixListConfiguration", "WorkWindowCompleted", "FacilityMapValidation", + "DirectPeeringTypeUpdateReadMaxPrefixLimit", "DirectPeeringTypeUpdateUpdatePortWithNewIP", + "DirectPeeringTypeUpdateConfigureLagWithNewIP", "DirectPeeringTypeUpdateCleanupOldIPsfromLAG", + "MapsToMapsVoiceUpdateIfDescription", "MapsToMapsVoicePrefixPrecheck", + "MapsToMapsVoiceUpdateLAGAcl", "MapsToMapsVoiceConfigureBFD", + "MapsToMapsVoiceFetchSessionState", "MapsToMapsVoicePrefixPostCheck", + "BgpGroupChangeRocPendingApproval", "BgpGroupChangeWorkWindow", "IPChangeWorkWindow", + "PendingASNChangeApplyDenyALL", "PendingASNChangeUpdateNeighborConfig", + "PendingASNChangeRemoveDenyALL", "PendingASNChangeUpdateInterfaceDescription", + "UpdateGraphForASNChange", "UpdatePeeringForASNChange", "AddDenyAllRocPendingApproval", + "AwaitApplyDenyAll", "IPChangeValidation", "IPChangeCleanup", "ForcedIpChangeCleanup", + "ForcedIpChangeCleanupWithActiveSessions", "IPChangeInitiate", "IPChangeLag", + "IPChangeBgpUpdate", "IPChangeMd5Configuration", "IPChangeApplyDenyAll", + "IPChangeRemoveDenyAll", "IPChangeValidateSessions", "ACLConfiguration", and + "PendingSpecialWorkItem". + :vartype previous_connection_provisioning_state: str or + ~azure.mgmt.peering.models.PreviousConnectionProvisioningState + :ivar migration_work_window_tracker: Gets or sets the migration work window tracker. Format = + "DateTime String Format|WorkWindowInitiator Email ID". + :vartype migration_work_window_tracker: str """ _validation = { @@ -642,8 +869,15 @@ class ExchangeConnection(_serialization.Model): "peering_db_facility_id": {"key": "peeringDBFacilityId", "type": "int"}, "connection_state": {"key": "connectionState", "type": "str"}, "bgp_session": {"key": "bgpSession", "type": "BgpSession"}, + "migration_work_window_bgp_session_same_device": { + "key": "migrationWorkWindowBgpSessionSameDevice", + "type": "{str}", + }, + "last_failure_time_utc": {"key": "lastFailureTimeUtc", "type": "iso-8601"}, "connection_identifier": {"key": "connectionIdentifier", "type": "str"}, "error_message": {"key": "errorMessage", "type": "str"}, + "previous_connection_provisioning_state": {"key": "previousConnectionProvisioningState", "type": "str"}, + "migration_work_window_tracker": {"key": "migrationWorkWindowTracker", "type": "str"}, } def __init__( @@ -651,24 +885,84 @@ def __init__( *, peering_db_facility_id: Optional[int] = None, bgp_session: Optional["_models.BgpSession"] = None, + migration_work_window_bgp_session_same_device: Optional[Dict[str, Union[str, "_models.Enum13"]]] = None, + last_failure_time_utc: Optional[datetime.datetime] = None, connection_identifier: Optional[str] = None, - **kwargs - ): + previous_connection_provisioning_state: Optional[ + Union[str, "_models.PreviousConnectionProvisioningState"] + ] = None, + migration_work_window_tracker: Optional[str] = None, + **kwargs: Any + ) -> None: """ :keyword peering_db_facility_id: The PeeringDB.com ID of the facility at which the connection has to be set up. :paramtype peering_db_facility_id: int :keyword bgp_session: The BGP session associated with the connection. :paramtype bgp_session: ~azure.mgmt.peering.models.BgpSession + :keyword migration_work_window_bgp_session_same_device: The old V4 BGP session associated with + the connection during migration on the same device. Will be used for Work-Window validation. + :paramtype migration_work_window_bgp_session_same_device: dict[str, str or + ~azure.mgmt.peering.models.Enum13] + :keyword last_failure_time_utc: Gets or sets the time corresponding to when the connection was + last set to ProvisioningFailed. + :paramtype last_failure_time_utc: ~datetime.datetime :keyword connection_identifier: The unique identifier (GUID) for the connection. :paramtype connection_identifier: str + :keyword previous_connection_provisioning_state: The previous connection provisioning state, + used to resume provisioning after connection has been blocked. Known values are: "None", + "InterconnectionPendingApproval", "DeviceStateValidation", "RocPendingApproval", + "AllocatePorts", "PortExhaustion", "CheckInterfaces", "EnableInterfaces", + "PhysicalConnectionSetup", "AwaitPairUpgrade", "LightCheck", "TestPing", "PingTestDone", + "AwaitPeerIps", "ValidateFltFirewall", "LagSetup", "AwaitLagCompletion", + "UpdateAddressesOnDevice", "FetchPrefixLimitFromPeeringDb", "BgpSessionConfiguration", + "NpmBgpSessionConfiguration", "Md5AuthKeyConfiguration", "FetchSessionState", "RemoveNomonit", + "UpdateApipaPrefixInSitepro", "ProvisioningCompleted", "PendingMigration", + "MigrationRequestPortAllocationRequested", "MigrationConfigValidation", + "PendingGlobalPolicyUpdate", "MigrationSpecificConfigDrift", "MigrationNpmError", + "PendingWorkWindow", "ExternalBlocker", "StaticMacConfiguration", "UndoMigrationGraphCleanup", + "MigrationWorkWindow", "PendingMigrationCompletion", "MigrationCompletionRequested", + "DirectPeeringTypeUpdateApproved", "DirectPeeringTypeUpdateRejected", + "DirectPeeringTypeUpdateIfDescription", "DirectPeeringTypeUpdatePrefixPrecheck", + "DirectPeeringTypeUpdateApplyDenyAll", "DirectPeeringTypeUpdateDeleteSession", + "DirectPeeringTypeUpdateLagAcl", "DirectPeeringTypeUpdateBgpConfig", + "DirectPeeringTypeUpdateFetchSessionState", "DirectPeeringTypeUpdateDeleteDenyAll", + "DirectPeeringTypeUpdatePrefixPostCheck", "DecomRocPendingApproval", "DecomAddDenyAll", + "DecomValidatePrefix", "DecomValidateTraffic", "DecomShutInterfaces", "DecomShutdownBgp", + "DecomCabling", "DecomRemoveBgpConfig", "DecomRemoveInterfaceConfig", "DecomGraphCleanup", + "DecomCompleted", "DirectPeeringTypeUpdateMd5AuthKeyConfiguration", "BfdConfiguration", + "DirectPeeringTypeUpdateBfdConfig", "DirectPeeringTypeUpdateMd5AuthKeyRead", + "PrefixListConfiguration", "WorkWindowCompleted", "FacilityMapValidation", + "DirectPeeringTypeUpdateReadMaxPrefixLimit", "DirectPeeringTypeUpdateUpdatePortWithNewIP", + "DirectPeeringTypeUpdateConfigureLagWithNewIP", "DirectPeeringTypeUpdateCleanupOldIPsfromLAG", + "MapsToMapsVoiceUpdateIfDescription", "MapsToMapsVoicePrefixPrecheck", + "MapsToMapsVoiceUpdateLAGAcl", "MapsToMapsVoiceConfigureBFD", + "MapsToMapsVoiceFetchSessionState", "MapsToMapsVoicePrefixPostCheck", + "BgpGroupChangeRocPendingApproval", "BgpGroupChangeWorkWindow", "IPChangeWorkWindow", + "PendingASNChangeApplyDenyALL", "PendingASNChangeUpdateNeighborConfig", + "PendingASNChangeRemoveDenyALL", "PendingASNChangeUpdateInterfaceDescription", + "UpdateGraphForASNChange", "UpdatePeeringForASNChange", "AddDenyAllRocPendingApproval", + "AwaitApplyDenyAll", "IPChangeValidation", "IPChangeCleanup", "ForcedIpChangeCleanup", + "ForcedIpChangeCleanupWithActiveSessions", "IPChangeInitiate", "IPChangeLag", + "IPChangeBgpUpdate", "IPChangeMd5Configuration", "IPChangeApplyDenyAll", + "IPChangeRemoveDenyAll", "IPChangeValidateSessions", "ACLConfiguration", and + "PendingSpecialWorkItem". + :paramtype previous_connection_provisioning_state: str or + ~azure.mgmt.peering.models.PreviousConnectionProvisioningState + :keyword migration_work_window_tracker: Gets or sets the migration work window tracker. Format + = "DateTime String Format|WorkWindowInitiator Email ID". + :paramtype migration_work_window_tracker: str """ super().__init__(**kwargs) self.peering_db_facility_id = peering_db_facility_id - self.connection_state = None + self.connection_state: Optional[Union[str, "_models.ConnectionState"]] = None self.bgp_session = bgp_session + self.migration_work_window_bgp_session_same_device = migration_work_window_bgp_session_same_device + self.last_failure_time_utc = last_failure_time_utc self.connection_identifier = connection_identifier - self.error_message = None + self.error_message: Optional[str] = None + self.previous_connection_provisioning_state = previous_connection_provisioning_state + self.migration_work_window_tracker = migration_work_window_tracker class ExchangePeeringFacility(_serialization.Model): @@ -715,8 +1009,8 @@ def __init__( facility_i_pv6_prefix: Optional[str] = None, peering_db_facility_id: Optional[int] = None, peering_db_facility_link: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword exchange_name: The name of the exchange peering facility. :paramtype exchange_name: str @@ -776,12 +1070,12 @@ class LogAnalyticsWorkspaceProperties(_serialization.Model): "connected_agents": {"key": "connectedAgents", "type": "[str]"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.workspace_id = None - self.key = None - self.connected_agents = None + self.workspace_id: Optional[str] = None + self.key: Optional[str] = None + self.connected_agents: Optional[List[str]] = None class LookingGlassOutput(_serialization.Model): @@ -799,8 +1093,8 @@ class LookingGlassOutput(_serialization.Model): } def __init__( - self, *, command: Optional[Union[str, "_models.Command"]] = None, output: Optional[str] = None, **kwargs - ): + self, *, command: Optional[Union[str, "_models.Command"]] = None, output: Optional[str] = None, **kwargs: Any + ) -> None: """ :keyword command: Invoked command. Known values are: "Traceroute", "Ping", and "BgpRoute". :paramtype command: str or ~azure.mgmt.peering.models.Command @@ -833,11 +1127,11 @@ class MetricDimension(_serialization.Model): "display_name": {"key": "displayName", "type": "str"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.name = None - self.display_name = None + self.name: Optional[str] = None + self.display_name: Optional[str] = None class MetricSpecification(_serialization.Model): @@ -882,16 +1176,16 @@ class MetricSpecification(_serialization.Model): "dimensions": {"key": "dimensions", "type": "[MetricDimension]"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.name = None - self.display_name = None - self.display_description = None - self.unit = None - self.aggregation_type = None - self.supported_time_grain_types = None - self.dimensions = None + self.name: Optional[str] = None + self.display_name: Optional[str] = None + self.display_description: Optional[str] = None + self.unit: Optional[str] = None + self.aggregation_type: Optional[str] = None + self.supported_time_grain_types: Optional[List[str]] = None + self.dimensions: Optional[List["_models.MetricDimension"]] = None class Operation(_serialization.Model): @@ -923,13 +1217,13 @@ class Operation(_serialization.Model): "service_specification": {"key": "properties.serviceSpecification", "type": "ServiceSpecification"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.name = None - self.display = None - self.is_data_action = None - self.service_specification = None + self.name: Optional[str] = None + self.display: Optional["_models.OperationDisplayInfo"] = None + self.is_data_action: Optional[bool] = None + self.service_specification: Optional["_models.ServiceSpecification"] = None class OperationDisplayInfo(_serialization.Model): @@ -961,13 +1255,13 @@ class OperationDisplayInfo(_serialization.Model): "description": {"key": "description", "type": "str"}, } - def __init__(self, **kwargs): + 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): @@ -984,7 +1278,9 @@ class OperationListResult(_serialization.Model): "next_link": {"key": "nextLink", "type": "str"}, } - def __init__(self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs): + def __init__( + self, *, value: Optional[List["_models.Operation"]] = None, next_link: Optional[str] = None, **kwargs: Any + ) -> None: """ :keyword value: The list of peering API operations. :paramtype value: list[~azure.mgmt.peering.models.Operation] @@ -1045,8 +1341,8 @@ def __init__( peer_asn: Optional[int] = None, peer_contact_detail: Optional[List["_models.ContactDetail"]] = None, peer_name: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword peer_asn: The Autonomous System Number (ASN) of the peer. :paramtype peer_asn: int @@ -1059,8 +1355,8 @@ def __init__( self.peer_asn = peer_asn self.peer_contact_detail = peer_contact_detail self.peer_name = peer_name - self.validation_state = None - self.error_message = None + self.validation_state: Optional[Union[str, "_models.ValidationState"]] = None + self.error_message: Optional[str] = None class PeerAsnListResult(_serialization.Model): @@ -1077,7 +1373,9 @@ class PeerAsnListResult(_serialization.Model): "next_link": {"key": "nextLink", "type": "str"}, } - def __init__(self, *, value: Optional[List["_models.PeerAsn"]] = None, next_link: Optional[str] = None, **kwargs): + def __init__( + self, *, value: Optional[List["_models.PeerAsn"]] = None, next_link: Optional[str] = None, **kwargs: Any + ) -> None: """ :keyword value: The list of peer ASNs. :paramtype value: list[~azure.mgmt.peering.models.PeerAsn] @@ -1089,12 +1387,13 @@ def __init__(self, *, value: Optional[List["_models.PeerAsn"]] = None, next_link self.next_link = next_link -class Peering(Resource): # pylint: disable=too-many-instance-attributes - """Peering is a logical representation of a set of connections to the Microsoft Cloud Edge at a location. +class Peering(Resource): + """Peering is a logical representation of a set of connections to the Microsoft Cloud Edge at a + location. Variables are only populated by the server, and will be ignored when sending a request. - All required parameters must be populated in order to send to Azure. + All required parameters must be populated in order to send to server. :ivar name: The name of the resource. :vartype name: str @@ -1114,6 +1413,8 @@ class Peering(Resource): # pylint: disable=too-many-instance-attributes :vartype direct: ~azure.mgmt.peering.models.PeeringPropertiesDirect :ivar exchange: The properties that define an exchange peering. :vartype exchange: ~azure.mgmt.peering.models.PeeringPropertiesExchange + :ivar connectivity_probes: The connectivity probes associated with the peering. + :vartype connectivity_probes: list[~azure.mgmt.peering.models.ConnectivityProbe] :ivar peering_location: The location of the peering. :vartype peering_location: str :ivar provisioning_state: The provisioning state of the resource. Known values are: @@ -1141,6 +1442,7 @@ class Peering(Resource): # pylint: disable=too-many-instance-attributes "tags": {"key": "tags", "type": "{str}"}, "direct": {"key": "properties.direct", "type": "PeeringPropertiesDirect"}, "exchange": {"key": "properties.exchange", "type": "PeeringPropertiesExchange"}, + "connectivity_probes": {"key": "properties.connectivityProbes", "type": "[ConnectivityProbe]"}, "peering_location": {"key": "properties.peeringLocation", "type": "str"}, "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, } @@ -1154,9 +1456,10 @@ def __init__( tags: Optional[Dict[str, str]] = None, direct: Optional["_models.PeeringPropertiesDirect"] = None, exchange: Optional["_models.PeeringPropertiesExchange"] = None, + connectivity_probes: Optional[List["_models.ConnectivityProbe"]] = None, peering_location: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword sku: The SKU that defines the tier and kind of the peering. Required. :paramtype sku: ~azure.mgmt.peering.models.PeeringSku @@ -1170,6 +1473,8 @@ def __init__( :paramtype direct: ~azure.mgmt.peering.models.PeeringPropertiesDirect :keyword exchange: The properties that define an exchange peering. :paramtype exchange: ~azure.mgmt.peering.models.PeeringPropertiesExchange + :keyword connectivity_probes: The connectivity probes associated with the peering. + :paramtype connectivity_probes: list[~azure.mgmt.peering.models.ConnectivityProbe] :keyword peering_location: The location of the peering. :paramtype peering_location: str """ @@ -1180,8 +1485,9 @@ def __init__( self.tags = tags self.direct = direct self.exchange = exchange + self.connectivity_probes = connectivity_probes self.peering_location = peering_location - self.provisioning_state = None + self.provisioning_state: Optional[Union[str, "_models.ProvisioningState"]] = None class PeeringBandwidthOffer(_serialization.Model): @@ -1198,7 +1504,7 @@ class PeeringBandwidthOffer(_serialization.Model): "value_in_mbps": {"key": "valueInMbps", "type": "int"}, } - def __init__(self, *, offer_name: Optional[str] = None, value_in_mbps: Optional[int] = None, **kwargs): + def __init__(self, *, offer_name: Optional[str] = None, value_in_mbps: Optional[int] = None, **kwargs: Any) -> None: """ :keyword offer_name: The name of the bandwidth offer. :paramtype offer_name: str @@ -1224,7 +1530,9 @@ class PeeringListResult(_serialization.Model): "next_link": {"key": "nextLink", "type": "str"}, } - def __init__(self, *, value: Optional[List["_models.Peering"]] = None, next_link: Optional[str] = None, **kwargs): + def __init__( + self, *, value: Optional[List["_models.Peering"]] = None, next_link: Optional[str] = None, **kwargs: Any + ) -> None: """ :keyword value: The list of peerings. :paramtype value: list[~azure.mgmt.peering.models.Peering] @@ -1289,8 +1597,8 @@ def __init__( peering_location: Optional[str] = None, country: Optional[str] = None, azure_region: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword kind: The kind of peering that the peering location supports. Known values are: "Direct" and "Exchange". @@ -1330,8 +1638,8 @@ class PeeringLocationListResult(_serialization.Model): } def __init__( - self, *, value: Optional[List["_models.PeeringLocation"]] = None, next_link: Optional[str] = None, **kwargs - ): + self, *, value: Optional[List["_models.PeeringLocation"]] = None, next_link: Optional[str] = None, **kwargs: Any + ) -> None: """ :keyword value: The list of peering locations. :paramtype value: list[~azure.mgmt.peering.models.PeeringLocation] @@ -1362,8 +1670,8 @@ def __init__( *, peering_facilities: Optional[List["_models.DirectPeeringFacility"]] = None, bandwidth_offers: Optional[List["_models.PeeringBandwidthOffer"]] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword peering_facilities: The list of direct peering facilities at the peering location. :paramtype peering_facilities: list[~azure.mgmt.peering.models.DirectPeeringFacility] @@ -1386,7 +1694,9 @@ class PeeringLocationPropertiesExchange(_serialization.Model): "peering_facilities": {"key": "peeringFacilities", "type": "[ExchangePeeringFacility]"}, } - def __init__(self, *, peering_facilities: Optional[List["_models.ExchangePeeringFacility"]] = None, **kwargs): + def __init__( + self, *, peering_facilities: Optional[List["_models.ExchangePeeringFacility"]] = None, **kwargs: Any + ) -> None: """ :keyword peering_facilities: The list of exchange peering facilities at the peering location. :paramtype peering_facilities: list[~azure.mgmt.peering.models.ExchangePeeringFacility] @@ -1408,7 +1718,7 @@ class PeeringPropertiesDirect(_serialization.Model): :ivar peer_asn: The reference of the peer ASN. :vartype peer_asn: ~azure.mgmt.peering.models.SubResource :ivar direct_peering_type: The type of direct peering. Known values are: "Edge", "Transit", - "Cdn", "Internal", "Ix", "IxRs", "Voice", and "EdgeZoneForOperators". + "Cdn", "Internal", "Ix", "IxRs", "Voice", "EdgeZoneForOperators", and "PeerProp". :vartype direct_peering_type: str or ~azure.mgmt.peering.models.DirectPeeringType """ @@ -1429,20 +1739,20 @@ def __init__( connections: Optional[List["_models.DirectConnection"]] = None, peer_asn: Optional["_models.SubResource"] = None, direct_peering_type: Optional[Union[str, "_models.DirectPeeringType"]] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword connections: The set of connections that constitute a direct peering. :paramtype connections: list[~azure.mgmt.peering.models.DirectConnection] :keyword peer_asn: The reference of the peer ASN. :paramtype peer_asn: ~azure.mgmt.peering.models.SubResource :keyword direct_peering_type: The type of direct peering. Known values are: "Edge", "Transit", - "Cdn", "Internal", "Ix", "IxRs", "Voice", and "EdgeZoneForOperators". + "Cdn", "Internal", "Ix", "IxRs", "Voice", "EdgeZoneForOperators", and "PeerProp". :paramtype direct_peering_type: str or ~azure.mgmt.peering.models.DirectPeeringType """ super().__init__(**kwargs) self.connections = connections - self.use_for_peering_service = None + self.use_for_peering_service: Optional[bool] = None self.peer_asn = peer_asn self.direct_peering_type = direct_peering_type @@ -1466,8 +1776,8 @@ def __init__( *, connections: Optional[List["_models.ExchangeConnection"]] = None, peer_asn: Optional["_models.SubResource"] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword connections: The set of connections that constitute an exchange peering. :paramtype connections: list[~azure.mgmt.peering.models.ExchangeConnection] @@ -1522,16 +1832,16 @@ class PeeringReceivedRoute(_serialization.Model): "received_timestamp": {"key": "receivedTimestamp", "type": "str"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.prefix = None - self.next_hop = None - self.as_path = None - self.origin_as_validation_state = None - self.rpki_validation_state = None - self.trust_anchor = None - self.received_timestamp = None + self.prefix: Optional[str] = None + self.next_hop: Optional[str] = None + self.as_path: Optional[str] = None + self.origin_as_validation_state: Optional[str] = None + self.rpki_validation_state: Optional[str] = None + self.trust_anchor: Optional[str] = None + self.received_timestamp: Optional[str] = None class PeeringReceivedRouteListResult(_serialization.Model): @@ -1549,8 +1859,12 @@ class PeeringReceivedRouteListResult(_serialization.Model): } def __init__( - self, *, value: Optional[List["_models.PeeringReceivedRoute"]] = None, next_link: Optional[str] = None, **kwargs - ): + self, + *, + value: Optional[List["_models.PeeringReceivedRoute"]] = None, + next_link: Optional[str] = None, + **kwargs: Any + ) -> None: """ :keyword value: The list of received routes for the peering. :paramtype value: list[~azure.mgmt.peering.models.PeeringReceivedRoute] @@ -1600,15 +1914,15 @@ class PeeringRegisteredAsn(Resource): "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, } - def __init__(self, *, asn: Optional[int] = None, **kwargs): + def __init__(self, *, asn: Optional[int] = None, **kwargs: Any) -> None: """ :keyword asn: The customer's ASN from which traffic originates. :paramtype asn: int """ super().__init__(**kwargs) self.asn = asn - self.peering_service_prefix_key = None - self.provisioning_state = None + self.peering_service_prefix_key: Optional[str] = None + self.provisioning_state: Optional[Union[str, "_models.ProvisioningState"]] = None class PeeringRegisteredAsnListResult(_serialization.Model): @@ -1626,8 +1940,12 @@ class PeeringRegisteredAsnListResult(_serialization.Model): } def __init__( - self, *, value: Optional[List["_models.PeeringRegisteredAsn"]] = None, next_link: Optional[str] = None, **kwargs - ): + self, + *, + value: Optional[List["_models.PeeringRegisteredAsn"]] = None, + next_link: Optional[str] = None, + **kwargs: Any + ) -> None: """ :keyword value: The list of peering registered ASNs. :paramtype value: list[~azure.mgmt.peering.models.PeeringRegisteredAsn] @@ -1686,17 +2004,17 @@ class PeeringRegisteredPrefix(Resource): "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, } - def __init__(self, *, prefix: Optional[str] = None, **kwargs): + def __init__(self, *, prefix: Optional[str] = None, **kwargs: Any) -> None: """ :keyword prefix: The customer's prefix from which traffic originates. :paramtype prefix: str """ super().__init__(**kwargs) self.prefix = prefix - self.prefix_validation_state = None - self.peering_service_prefix_key = None - self.error_message = None - self.provisioning_state = None + self.prefix_validation_state: Optional[Union[str, "_models.PrefixValidationState"]] = None + self.peering_service_prefix_key: Optional[str] = None + self.error_message: Optional[str] = None + self.provisioning_state: Optional[Union[str, "_models.ProvisioningState"]] = None class PeeringRegisteredPrefixListResult(_serialization.Model): @@ -1718,8 +2036,8 @@ def __init__( *, value: Optional[List["_models.PeeringRegisteredPrefix"]] = None, next_link: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword value: The list of peering registered prefixes. :paramtype value: list[~azure.mgmt.peering.models.PeeringRegisteredPrefix] @@ -1731,12 +2049,12 @@ def __init__( self.next_link = next_link -class PeeringService(Resource): # pylint: disable=too-many-instance-attributes +class PeeringService(Resource): """Peering Service. 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 name: The name of the resource. :vartype name: str @@ -1805,8 +2123,8 @@ def __init__( provider_primary_peering_location: Optional[str] = None, provider_backup_peering_location: Optional[str] = None, log_analytics_workspace_properties: Optional["_models.LogAnalyticsWorkspaceProperties"] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword sku: The SKU that defines the type of the peering service. :paramtype sku: ~azure.mgmt.peering.models.PeeringServiceSku @@ -1834,7 +2152,7 @@ def __init__( self.tags = tags self.peering_service_location = peering_service_location self.peering_service_provider = peering_service_provider - self.provisioning_state = None + self.provisioning_state: Optional[Union[str, "_models.ProvisioningState"]] = None self.provider_primary_peering_location = provider_primary_peering_location self.provider_backup_peering_location = provider_backup_peering_location self.log_analytics_workspace_properties = log_analytics_workspace_properties @@ -1853,22 +2171,6 @@ class PeeringServiceCountry(Resource): :vartype type: str """ - _validation = { - "name": {"readonly": True}, - "id": {"readonly": True}, - "type": {"readonly": True}, - } - - _attribute_map = { - "name": {"key": "name", "type": "str"}, - "id": {"key": "id", "type": "str"}, - "type": {"key": "type", "type": "str"}, - } - - def __init__(self, **kwargs): - """ """ - super().__init__(**kwargs) - class PeeringServiceCountryListResult(_serialization.Model): """The paginated list of peering service countries. @@ -1889,8 +2191,8 @@ def __init__( *, value: Optional[List["_models.PeeringServiceCountry"]] = None, next_link: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword value: The list of peering service countries. :paramtype value: list[~azure.mgmt.peering.models.PeeringServiceCountry] @@ -1917,8 +2219,8 @@ class PeeringServiceListResult(_serialization.Model): } def __init__( - self, *, value: Optional[List["_models.PeeringService"]] = None, next_link: Optional[str] = None, **kwargs - ): + self, *, value: Optional[List["_models.PeeringService"]] = None, next_link: Optional[str] = None, **kwargs: Any + ) -> None: """ :keyword value: The list of peering services. :paramtype value: list[~azure.mgmt.peering.models.PeeringService] @@ -1970,8 +2272,8 @@ def __init__( country: Optional[str] = None, state: Optional[str] = None, azure_region: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword country: Country of the customer. :paramtype country: str @@ -2005,8 +2307,8 @@ def __init__( *, value: Optional[List["_models.PeeringServiceLocation"]] = None, next_link: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword value: The list of peering service locations. :paramtype value: list[~azure.mgmt.peering.models.PeeringServiceLocation] @@ -2072,7 +2374,9 @@ class PeeringServicePrefix(Resource): "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, } - def __init__(self, *, prefix: Optional[str] = None, peering_service_prefix_key: Optional[str] = None, **kwargs): + def __init__( + self, *, prefix: Optional[str] = None, peering_service_prefix_key: Optional[str] = None, **kwargs: Any + ) -> None: """ :keyword prefix: The prefix from which your traffic originates. :paramtype prefix: str @@ -2081,12 +2385,12 @@ def __init__(self, *, prefix: Optional[str] = None, peering_service_prefix_key: """ super().__init__(**kwargs) self.prefix = prefix - self.prefix_validation_state = None - self.learned_type = None - self.error_message = None - self.events = None + self.prefix_validation_state: Optional[Union[str, "_models.PrefixValidationState"]] = None + self.learned_type: Optional[Union[str, "_models.LearnedType"]] = None + self.error_message: Optional[str] = None + self.events: Optional[List["_models.PeeringServicePrefixEvent"]] = None self.peering_service_prefix_key = peering_service_prefix_key - self.provisioning_state = None + self.provisioning_state: Optional[Union[str, "_models.ProvisioningState"]] = None class PeeringServicePrefixEvent(_serialization.Model): @@ -2122,14 +2426,14 @@ class PeeringServicePrefixEvent(_serialization.Model): "event_description": {"key": "eventDescription", "type": "str"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.event_timestamp = None - self.event_type = None - self.event_summary = None - self.event_level = None - self.event_description = None + self.event_timestamp: Optional[datetime.datetime] = None + self.event_type: Optional[str] = None + self.event_summary: Optional[str] = None + self.event_level: Optional[str] = None + self.event_description: Optional[str] = None class PeeringServicePrefixListResult(_serialization.Model): @@ -2147,8 +2451,12 @@ class PeeringServicePrefixListResult(_serialization.Model): } def __init__( - self, *, value: Optional[List["_models.PeeringServicePrefix"]] = None, next_link: Optional[str] = None, **kwargs - ): + self, + *, + value: Optional[List["_models.PeeringServicePrefix"]] = None, + next_link: Optional[str] = None, + **kwargs: Any + ) -> None: """ :keyword value: The list of peering service prefixes. :paramtype value: list[~azure.mgmt.peering.models.PeeringServicePrefix] @@ -2193,8 +2501,12 @@ class PeeringServiceProvider(Resource): } def __init__( - self, *, service_provider_name: Optional[str] = None, peering_locations: Optional[List[str]] = None, **kwargs - ): + self, + *, + service_provider_name: Optional[str] = None, + peering_locations: Optional[List[str]] = None, + **kwargs: Any + ) -> None: """ :keyword service_provider_name: The name of the service provider. :paramtype service_provider_name: str @@ -2226,8 +2538,8 @@ def __init__( *, value: Optional[List["_models.PeeringServiceProvider"]] = None, next_link: Optional[str] = None, - **kwargs - ): + **kwargs: Any + ) -> None: """ :keyword value: The list of peering service providers. :paramtype value: list[~azure.mgmt.peering.models.PeeringServiceProvider] @@ -2250,7 +2562,7 @@ class PeeringServiceSku(_serialization.Model): "name": {"key": "name", "type": "str"}, } - def __init__(self, *, name: Optional[str] = None, **kwargs): + def __init__(self, *, name: Optional[str] = None, **kwargs: Any) -> None: """ :keyword name: The name of the peering service SKU. :paramtype name: str @@ -2287,16 +2599,16 @@ class PeeringSku(_serialization.Model): "size": {"key": "size", "type": "str"}, } - def __init__(self, *, name: Optional[str] = None, **kwargs): + def __init__(self, *, name: Optional[str] = None, **kwargs: Any) -> None: """ :keyword name: The name of the peering SKU. :paramtype name: str """ super().__init__(**kwargs) self.name = name - self.tier = None - self.family = None - self.size = None + self.tier: Optional[Union[str, "_models.Tier"]] = None + self.family: Optional[Union[str, "_models.Family"]] = None + self.size: Optional[Union[str, "_models.Size"]] = None class ResourceTags(_serialization.Model): @@ -2310,7 +2622,7 @@ class ResourceTags(_serialization.Model): "tags": {"key": "tags", "type": "{str}"}, } - def __init__(self, *, tags: Optional[Dict[str, str]] = None, **kwargs): + def __init__(self, *, tags: Optional[Dict[str, str]] = None, **kwargs: Any) -> None: """ :keyword tags: Gets or sets the tags, a dictionary of descriptors arm object. :paramtype tags: dict[str, str] @@ -2344,12 +2656,12 @@ class RpUnbilledPrefix(_serialization.Model): "peer_asn": {"key": "peerAsn", "type": "int"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.prefix = None - self.azure_region = None - self.peer_asn = None + self.prefix: Optional[str] = None + self.azure_region: Optional[str] = None + self.peer_asn: Optional[int] = None class RpUnbilledPrefixListResult(_serialization.Model): @@ -2367,8 +2679,12 @@ class RpUnbilledPrefixListResult(_serialization.Model): } def __init__( - self, *, value: Optional[List["_models.RpUnbilledPrefix"]] = None, next_link: Optional[str] = None, **kwargs - ): + self, + *, + value: Optional[List["_models.RpUnbilledPrefix"]] = None, + next_link: Optional[str] = None, + **kwargs: Any + ) -> None: """ :keyword value: The list of RP unbilled prefixes. :paramtype value: list[~azure.mgmt.peering.models.RpUnbilledPrefix] @@ -2397,10 +2713,10 @@ class ServiceSpecification(_serialization.Model): "metric_specifications": {"key": "metricSpecifications", "type": "[MetricSpecification]"}, } - def __init__(self, **kwargs): + def __init__(self, **kwargs: Any) -> None: """ """ super().__init__(**kwargs) - self.metric_specifications = None + self.metric_specifications: Optional[List["_models.MetricSpecification"]] = None class SubResource(_serialization.Model): @@ -2414,7 +2730,7 @@ class SubResource(_serialization.Model): "id": {"key": "id", "type": "str"}, } - def __init__(self, *, id: Optional[str] = None, **kwargs): # pylint: disable=redefined-builtin + def __init__(self, *, id: Optional[str] = None, **kwargs: Any) -> None: # pylint: disable=redefined-builtin """ :keyword id: The identifier of the referenced resource. :paramtype id: str diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/models/_peering_management_client_enums.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/models/_peering_management_client_enums.py index 8ae0a7559e10..8f4ac5ddb605 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/models/_peering_management_client_enums.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/models/_peering_management_client_enums.py @@ -31,6 +31,7 @@ class ConnectionState(str, Enum, metaclass=CaseInsensitiveEnumMeta): ACTIVE = "Active" TYPE_CHANGE_REQUESTED = "TypeChangeRequested" TYPE_CHANGE_IN_PROGRESS = "TypeChangeInProgress" + EXTERNAL_BLOCKER = "ExternalBlocker" class DirectPeeringType(str, Enum, metaclass=CaseInsensitiveEnumMeta): @@ -44,6 +45,7 @@ class DirectPeeringType(str, Enum, metaclass=CaseInsensitiveEnumMeta): IX_RS = "IxRs" VOICE = "Voice" EDGE_ZONE_FOR_OPERATORS = "EdgeZoneForOperators" + PEER_PROP = "PeerProp" class Enum0(str, Enum, metaclass=CaseInsensitiveEnumMeta): @@ -53,6 +55,38 @@ class Enum0(str, Enum, metaclass=CaseInsensitiveEnumMeta): UNAVAILABLE = "Unavailable" +class Enum11(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Enum11.""" + + NONE = "None" + IDLE = "Idle" + CONNECT = "Connect" + ACTIVE = "Active" + OPEN_SENT = "OpenSent" + OPEN_CONFIRM = "OpenConfirm" + OPEN_RECEIVED = "OpenReceived" + ESTABLISHED = "Established" + PENDING_ADD = "PendingAdd" + PENDING_UPDATE = "PendingUpdate" + PENDING_REMOVE = "PendingRemove" + + +class Enum13(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Enum13.""" + + NONE = "None" + IDLE = "Idle" + CONNECT = "Connect" + ACTIVE = "Active" + OPEN_SENT = "OpenSent" + OPEN_CONFIRM = "OpenConfirm" + OPEN_RECEIVED = "OpenReceived" + ESTABLISHED = "Established" + PENDING_ADD = "PendingAdd" + PENDING_UPDATE = "PendingUpdate" + PENDING_REMOVE = "PendingRemove" + + class Family(str, Enum, metaclass=CaseInsensitiveEnumMeta): """The family of the peering SKU.""" @@ -108,6 +142,7 @@ class PeeringLocationsDirectPeeringType(str, Enum, metaclass=CaseInsensitiveEnum IX_RS = "IxRs" VOICE = "Voice" EDGE_ZONE_FOR_OPERATORS = "EdgeZoneForOperators" + PEER_PROP = "PeerProp" class PeeringLocationsKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): @@ -129,6 +164,123 @@ class PrefixValidationState(str, Enum, metaclass=CaseInsensitiveEnumMeta): UNKNOWN = "Unknown" +class PreviousConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """The previous connection provisioning state, used to resume provisioning after connection has + been blocked. + """ + + NONE = "None" + INTERCONNECTION_PENDING_APPROVAL = "InterconnectionPendingApproval" + DEVICE_STATE_VALIDATION = "DeviceStateValidation" + ROC_PENDING_APPROVAL = "RocPendingApproval" + ALLOCATE_PORTS = "AllocatePorts" + PORT_EXHAUSTION = "PortExhaustion" + CHECK_INTERFACES = "CheckInterfaces" + ENABLE_INTERFACES = "EnableInterfaces" + PHYSICAL_CONNECTION_SETUP = "PhysicalConnectionSetup" + AWAIT_PAIR_UPGRADE = "AwaitPairUpgrade" + LIGHT_CHECK = "LightCheck" + TEST_PING = "TestPing" + PING_TEST_DONE = "PingTestDone" + AWAIT_PEER_IPS = "AwaitPeerIps" + VALIDATE_FLT_FIREWALL = "ValidateFltFirewall" + LAG_SETUP = "LagSetup" + AWAIT_LAG_COMPLETION = "AwaitLagCompletion" + UPDATE_ADDRESSES_ON_DEVICE = "UpdateAddressesOnDevice" + FETCH_PREFIX_LIMIT_FROM_PEERING_DB = "FetchPrefixLimitFromPeeringDb" + BGP_SESSION_CONFIGURATION = "BgpSessionConfiguration" + NPM_BGP_SESSION_CONFIGURATION = "NpmBgpSessionConfiguration" + MD5_AUTH_KEY_CONFIGURATION = "Md5AuthKeyConfiguration" + FETCH_SESSION_STATE = "FetchSessionState" + REMOVE_NOMONIT = "RemoveNomonit" + UPDATE_APIPA_PREFIX_IN_SITEPRO = "UpdateApipaPrefixInSitepro" + PROVISIONING_COMPLETED = "ProvisioningCompleted" + PENDING_MIGRATION = "PendingMigration" + MIGRATION_REQUEST_PORT_ALLOCATION_REQUESTED = "MigrationRequestPortAllocationRequested" + MIGRATION_CONFIG_VALIDATION = "MigrationConfigValidation" + PENDING_GLOBAL_POLICY_UPDATE = "PendingGlobalPolicyUpdate" + MIGRATION_SPECIFIC_CONFIG_DRIFT = "MigrationSpecificConfigDrift" + MIGRATION_NPM_ERROR = "MigrationNpmError" + PENDING_WORK_WINDOW = "PendingWorkWindow" + EXTERNAL_BLOCKER = "ExternalBlocker" + STATIC_MAC_CONFIGURATION = "StaticMacConfiguration" + UNDO_MIGRATION_GRAPH_CLEANUP = "UndoMigrationGraphCleanup" + MIGRATION_WORK_WINDOW = "MigrationWorkWindow" + PENDING_MIGRATION_COMPLETION = "PendingMigrationCompletion" + MIGRATION_COMPLETION_REQUESTED = "MigrationCompletionRequested" + DIRECT_PEERING_TYPE_UPDATE_APPROVED = "DirectPeeringTypeUpdateApproved" + DIRECT_PEERING_TYPE_UPDATE_REJECTED = "DirectPeeringTypeUpdateRejected" + DIRECT_PEERING_TYPE_UPDATE_IF_DESCRIPTION = "DirectPeeringTypeUpdateIfDescription" + DIRECT_PEERING_TYPE_UPDATE_PREFIX_PRECHECK = "DirectPeeringTypeUpdatePrefixPrecheck" + DIRECT_PEERING_TYPE_UPDATE_APPLY_DENY_ALL = "DirectPeeringTypeUpdateApplyDenyAll" + DIRECT_PEERING_TYPE_UPDATE_DELETE_SESSION = "DirectPeeringTypeUpdateDeleteSession" + DIRECT_PEERING_TYPE_UPDATE_LAG_ACL = "DirectPeeringTypeUpdateLagAcl" + DIRECT_PEERING_TYPE_UPDATE_BGP_CONFIG = "DirectPeeringTypeUpdateBgpConfig" + DIRECT_PEERING_TYPE_UPDATE_FETCH_SESSION_STATE = "DirectPeeringTypeUpdateFetchSessionState" + DIRECT_PEERING_TYPE_UPDATE_DELETE_DENY_ALL = "DirectPeeringTypeUpdateDeleteDenyAll" + DIRECT_PEERING_TYPE_UPDATE_PREFIX_POST_CHECK = "DirectPeeringTypeUpdatePrefixPostCheck" + DECOM_ROC_PENDING_APPROVAL = "DecomRocPendingApproval" + DECOM_ADD_DENY_ALL = "DecomAddDenyAll" + DECOM_VALIDATE_PREFIX = "DecomValidatePrefix" + DECOM_VALIDATE_TRAFFIC = "DecomValidateTraffic" + DECOM_SHUT_INTERFACES = "DecomShutInterfaces" + DECOM_SHUTDOWN_BGP = "DecomShutdownBgp" + DECOM_CABLING = "DecomCabling" + DECOM_REMOVE_BGP_CONFIG = "DecomRemoveBgpConfig" + DECOM_REMOVE_INTERFACE_CONFIG = "DecomRemoveInterfaceConfig" + DECOM_GRAPH_CLEANUP = "DecomGraphCleanup" + DECOM_COMPLETED = "DecomCompleted" + DIRECT_PEERING_TYPE_UPDATE_MD5_AUTH_KEY_CONFIGURATION = "DirectPeeringTypeUpdateMd5AuthKeyConfiguration" + BFD_CONFIGURATION = "BfdConfiguration" + DIRECT_PEERING_TYPE_UPDATE_BFD_CONFIG = "DirectPeeringTypeUpdateBfdConfig" + DIRECT_PEERING_TYPE_UPDATE_MD5_AUTH_KEY_READ = "DirectPeeringTypeUpdateMd5AuthKeyRead" + PREFIX_LIST_CONFIGURATION = "PrefixListConfiguration" + WORK_WINDOW_COMPLETED = "WorkWindowCompleted" + FACILITY_MAP_VALIDATION = "FacilityMapValidation" + DIRECT_PEERING_TYPE_UPDATE_READ_MAX_PREFIX_LIMIT = "DirectPeeringTypeUpdateReadMaxPrefixLimit" + DIRECT_PEERING_TYPE_UPDATE_UPDATE_PORT_WITH_NEW_IP = "DirectPeeringTypeUpdateUpdatePortWithNewIP" + DIRECT_PEERING_TYPE_UPDATE_CONFIGURE_LAG_WITH_NEW_IP = "DirectPeeringTypeUpdateConfigureLagWithNewIP" + DIRECT_PEERING_TYPE_UPDATE_CLEANUP_OLD_I_PSFROM_LAG = "DirectPeeringTypeUpdateCleanupOldIPsfromLAG" + MAPS_TO_MAPS_VOICE_UPDATE_IF_DESCRIPTION = "MapsToMapsVoiceUpdateIfDescription" + MAPS_TO_MAPS_VOICE_PREFIX_PRECHECK = "MapsToMapsVoicePrefixPrecheck" + MAPS_TO_MAPS_VOICE_UPDATE_LAG_ACL = "MapsToMapsVoiceUpdateLAGAcl" + MAPS_TO_MAPS_VOICE_CONFIGURE_BFD = "MapsToMapsVoiceConfigureBFD" + MAPS_TO_MAPS_VOICE_FETCH_SESSION_STATE = "MapsToMapsVoiceFetchSessionState" + MAPS_TO_MAPS_VOICE_PREFIX_POST_CHECK = "MapsToMapsVoicePrefixPostCheck" + BGP_GROUP_CHANGE_ROC_PENDING_APPROVAL = "BgpGroupChangeRocPendingApproval" + BGP_GROUP_CHANGE_WORK_WINDOW = "BgpGroupChangeWorkWindow" + IP_CHANGE_WORK_WINDOW = "IPChangeWorkWindow" + PENDING_ASN_CHANGE_APPLY_DENY_ALL = "PendingASNChangeApplyDenyALL" + PENDING_ASN_CHANGE_UPDATE_NEIGHBOR_CONFIG = "PendingASNChangeUpdateNeighborConfig" + PENDING_ASN_CHANGE_REMOVE_DENY_ALL = "PendingASNChangeRemoveDenyALL" + PENDING_ASN_CHANGE_UPDATE_INTERFACE_DESCRIPTION = "PendingASNChangeUpdateInterfaceDescription" + UPDATE_GRAPH_FOR_ASN_CHANGE = "UpdateGraphForASNChange" + UPDATE_PEERING_FOR_ASN_CHANGE = "UpdatePeeringForASNChange" + ADD_DENY_ALL_ROC_PENDING_APPROVAL = "AddDenyAllRocPendingApproval" + AWAIT_APPLY_DENY_ALL = "AwaitApplyDenyAll" + IP_CHANGE_VALIDATION = "IPChangeValidation" + IP_CHANGE_CLEANUP = "IPChangeCleanup" + FORCED_IP_CHANGE_CLEANUP = "ForcedIpChangeCleanup" + FORCED_IP_CHANGE_CLEANUP_WITH_ACTIVE_SESSIONS = "ForcedIpChangeCleanupWithActiveSessions" + IP_CHANGE_INITIATE = "IPChangeInitiate" + IP_CHANGE_LAG = "IPChangeLag" + IP_CHANGE_BGP_UPDATE = "IPChangeBgpUpdate" + IP_CHANGE_MD5_CONFIGURATION = "IPChangeMd5Configuration" + IP_CHANGE_APPLY_DENY_ALL = "IPChangeApplyDenyAll" + IP_CHANGE_REMOVE_DENY_ALL = "IPChangeRemoveDenyAll" + IP_CHANGE_VALIDATE_SESSIONS = "IPChangeValidateSessions" + ACL_CONFIGURATION = "ACLConfiguration" + PENDING_SPECIAL_WORK_ITEM = "PendingSpecialWorkItem" + + +class Protocol(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """The protocol of the traffic that will be sent.""" + + NONE = "None" + ICMP = "ICMP" + TCP = "TCP" + + class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): """The provisioning state of the resource.""" diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/__init__.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/__init__.py index 3a7f6307d71e..847358e61cce 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/__init__.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/__init__.py @@ -5,28 +5,34 @@ # 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 ._cdn_peering_prefixes_operations import CdnPeeringPrefixesOperations -from ._peering_management_client_operations import PeeringManagementClientOperationsMixin -from ._legacy_peerings_operations import LegacyPeeringsOperations -from ._looking_glass_operations import LookingGlassOperations -from ._operations import Operations -from ._peer_asns_operations import PeerAsnsOperations -from ._peering_locations_operations import PeeringLocationsOperations -from ._registered_asns_operations import RegisteredAsnsOperations -from ._registered_prefixes_operations import RegisteredPrefixesOperations -from ._peerings_operations import PeeringsOperations -from ._received_routes_operations import ReceivedRoutesOperations -from ._connection_monitor_tests_operations import ConnectionMonitorTestsOperations -from ._peering_service_countries_operations import PeeringServiceCountriesOperations -from ._peering_service_locations_operations import PeeringServiceLocationsOperations -from ._prefixes_operations import PrefixesOperations -from ._peering_service_providers_operations import PeeringServiceProvidersOperations -from ._peering_services_operations import PeeringServicesOperations -from ._rp_unbilled_prefixes_operations import RpUnbilledPrefixesOperations +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ._patch import * # pylint: disable=unused-wildcard-import + +from ._cdn_peering_prefixes_operations import CdnPeeringPrefixesOperations # type: ignore +from ._peering_management_client_operations import PeeringManagementClientOperationsMixin # type: ignore +from ._legacy_peerings_operations import LegacyPeeringsOperations # type: ignore +from ._looking_glass_operations import LookingGlassOperations # type: ignore +from ._operations import Operations # type: ignore +from ._peer_asns_operations import PeerAsnsOperations # type: ignore +from ._peering_locations_operations import PeeringLocationsOperations # type: ignore +from ._registered_asns_operations import RegisteredAsnsOperations # type: ignore +from ._registered_prefixes_operations import RegisteredPrefixesOperations # type: ignore +from ._peerings_operations import PeeringsOperations # type: ignore +from ._received_routes_operations import ReceivedRoutesOperations # type: ignore +from ._connection_monitor_tests_operations import ConnectionMonitorTestsOperations # type: ignore +from ._peering_service_countries_operations import PeeringServiceCountriesOperations # type: ignore +from ._peering_service_locations_operations import PeeringServiceLocationsOperations # type: ignore +from ._prefixes_operations import PrefixesOperations # type: ignore +from ._peering_service_providers_operations import PeeringServiceProvidersOperations # type: ignore +from ._peering_services_operations import PeeringServicesOperations # type: ignore +from ._rp_unbilled_prefixes_operations import RpUnbilledPrefixesOperations # type: ignore from ._patch import __all__ as _patch_all -from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ @@ -49,5 +55,5 @@ "PeeringServicesOperations", "RpUnbilledPrefixesOperations", ] -__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/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_cdn_peering_prefixes_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_cdn_peering_prefixes_operations.py index c5ab3a4d6687..dfe1d67b74b8 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_cdn_peering_prefixes_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_cdn_peering_prefixes_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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, @@ -20,20 +20,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -45,7 +40,7 @@ def build_list_request(subscription_id: str, *, peering_location: str, **kwargs: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -54,7 +49,7 @@ def build_list_request(subscription_id: str, *, peering_location: str, **kwargs: "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["peeringLocation"] = _SERIALIZER.query("peering_location", peering_location, "str") @@ -80,10 +75,10 @@ class CdnPeeringPrefixesOperations: 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: PeeringManagementClientConfiguration = 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, peering_location: str, **kwargs: Any) -> Iterable["_models.CdnPeeringPrefix"]: @@ -91,7 +86,6 @@ def list(self, peering_location: str, **kwargs: Any) -> Iterable["_models.CdnPee :param peering_location: The peering location. Required. :type peering_location: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either CdnPeeringPrefix or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.CdnPeeringPrefix] :raises ~azure.core.exceptions.HttpResponseError: @@ -99,12 +93,10 @@ def list(self, peering_location: str, **kwargs: Any) -> Iterable["_models.CdnPee _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.CdnPeeringPrefixListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.CdnPeeringPrefixListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -115,16 +107,14 @@ def list(self, peering_location: str, **kwargs: Any) -> Iterable["_models.CdnPee def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( subscription_id=self._config.subscription_id, peering_location=peering_location, api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -136,26 +126,26 @@ 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) # type: ignore - 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("CdnPeeringPrefixListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -167,5 +157,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/cdnPeeringPrefixes"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_connection_monitor_tests_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_connection_monitor_tests_operations.py index a68ecbcfa0bd..569a0ab38e76 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_connection_monitor_tests_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_connection_monitor_tests_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. # -------------------------------------------------------------------------- -import sys +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,20 +22,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -51,14 +48,14 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/connectionMonitorTests/{connectionMonitorTestName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringServiceName": _SERIALIZER.url("peering_service_name", peering_service_name, "str"), @@ -68,7 +65,7 @@ def build_get_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -89,15 +86,15 @@ def build_create_or_update_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) + 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.Peering/peeringServices/{peeringServiceName}/connectionMonitorTests/{connectionMonitorTestName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringServiceName": _SERIALIZER.url("peering_service_name", peering_service_name, "str"), @@ -107,7 +104,7 @@ def build_create_or_update_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -130,14 +127,14 @@ def build_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/connectionMonitorTests/{connectionMonitorTestName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringServiceName": _SERIALIZER.url("peering_service_name", peering_service_name, "str"), @@ -147,7 +144,7 @@ def build_delete_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -164,21 +161,21 @@ def build_list_by_peering_service_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/connectionMonitorTests", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringServiceName": _SERIALIZER.url("peering_service_name", peering_service_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -203,10 +200,10 @@ class ConnectionMonitorTestsOperations: 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: PeeringManagementClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace def get( @@ -221,12 +218,11 @@ def get( :type peering_service_name: str :param connection_monitor_test_name: The name of the connection monitor test. Required. :type connection_monitor_test_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: ConnectionMonitorTest or the result of cls(response) :rtype: ~azure.mgmt.peering.models.ConnectionMonitorTest :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -237,26 +233,23 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ConnectionMonitorTest] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.ConnectionMonitorTest] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, connection_monitor_test_name=connection_monitor_test_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -266,14 +259,12 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("ConnectionMonitorTest", pipeline_response) + deserialized = self._deserialize("ConnectionMonitorTest", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/connectionMonitorTests/{connectionMonitorTestName}"} # type: ignore + return deserialized # type: ignore @overload def create_or_update( @@ -301,7 +292,6 @@ def create_or_update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: ConnectionMonitorTest or the result of cls(response) :rtype: ~azure.mgmt.peering.models.ConnectionMonitorTest :raises ~azure.core.exceptions.HttpResponseError: @@ -313,7 +303,7 @@ def create_or_update( resource_group_name: str, peering_service_name: str, connection_monitor_test_name: str, - connection_monitor_test: IO, + connection_monitor_test: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -329,11 +319,10 @@ def create_or_update( :type connection_monitor_test_name: str :param connection_monitor_test: The properties needed to create a connection monitor test. Required. - :type connection_monitor_test: IO + :type connection_monitor_test: 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: ConnectionMonitorTest or the result of cls(response) :rtype: ~azure.mgmt.peering.models.ConnectionMonitorTest :raises ~azure.core.exceptions.HttpResponseError: @@ -345,7 +334,7 @@ def create_or_update( resource_group_name: str, peering_service_name: str, connection_monitor_test_name: str, - connection_monitor_test: Union[_models.ConnectionMonitorTest, IO], + connection_monitor_test: Union[_models.ConnectionMonitorTest, IO[bytes]], **kwargs: Any ) -> _models.ConnectionMonitorTest: """Creates or updates a connection monitor test with the specified name under the given @@ -358,17 +347,13 @@ def create_or_update( :param connection_monitor_test_name: The name of the connection monitor test. Required. :type connection_monitor_test_name: str :param connection_monitor_test: The properties needed to create a connection monitor test. Is - either a model type or a IO type. Required. - :type connection_monitor_test: ~azure.mgmt.peering.models.ConnectionMonitorTest 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 + either a ConnectionMonitorTest type or a IO[bytes] type. Required. + :type connection_monitor_test: ~azure.mgmt.peering.models.ConnectionMonitorTest or IO[bytes] :return: ConnectionMonitorTest or the result of cls(response) :rtype: ~azure.mgmt.peering.models.ConnectionMonitorTest :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -379,21 +364,19 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ConnectionMonitorTest] + 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.ConnectionMonitorTest] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(connection_monitor_test, (IO, bytes)): + if isinstance(connection_monitor_test, (IOBase, bytes)): _content = connection_monitor_test else: _json = self._serialize.body(connection_monitor_test, "ConnectionMonitorTest") - request = build_create_or_update_request( + _request = build_create_or_update_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, connection_monitor_test_name=connection_monitor_test_name, @@ -402,15 +385,14 @@ def create_or_update( content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -420,18 +402,12 @@ def create_or_update( 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("ConnectionMonitorTest", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("ConnectionMonitorTest", pipeline_response) + deserialized = self._deserialize("ConnectionMonitorTest", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/connectionMonitorTests/{connectionMonitorTestName}"} # type: ignore + return deserialized # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -446,12 +422,11 @@ def delete( # pylint: disable=inconsistent-return-statements :type peering_service_name: str :param connection_monitor_test_name: The name of the connection monitor test. Required. :type connection_monitor_test_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, @@ -462,26 +437,23 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + 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, peering_service_name=peering_service_name, connection_monitor_test_name=connection_monitor_test_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -492,9 +464,7 @@ 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.Peering/peeringServices/{peeringServiceName}/connectionMonitorTests/{connectionMonitorTestName}"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore @distributed_trace def list_by_peering_service( @@ -507,7 +477,6 @@ def list_by_peering_service( :type resource_group_name: str :param peering_service_name: The name of the peering service. Required. :type peering_service_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either ConnectionMonitorTest or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.ConnectionMonitorTest] @@ -516,12 +485,10 @@ def list_by_peering_service( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ConnectionMonitorTestListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.ConnectionMonitorTestListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -532,17 +499,15 @@ def list_by_peering_service( def prepare_request(next_link=None): if not next_link: - request = build_list_by_peering_service_request( + _request = build_list_by_peering_service_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_peering_service.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -554,26 +519,26 @@ 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) # type: ignore - 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("ConnectionMonitorTestListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -585,5 +550,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list_by_peering_service.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/connectionMonitorTests"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_legacy_peerings_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_legacy_peerings_operations.py index d970eac838d6..99cde6cea30d 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_legacy_peerings_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_legacy_peerings_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from collections.abc import MutableMapping from typing import Any, Callable, Dict, Iterable, Optional, TypeVar, Union import urllib.parse +from azure.core import PipelineClient from azure.core.exceptions import ( ClientAuthenticationError, HttpResponseError, @@ -20,20 +20,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -53,7 +48,7 @@ def build_list_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -62,7 +57,7 @@ def build_list_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["peeringLocation"] = _SERIALIZER.query("peering_location", peering_location, "str") @@ -93,10 +88,10 @@ class LegacyPeeringsOperations: 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: PeeringManagementClientConfiguration = 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( @@ -117,9 +112,9 @@ def list( :param asn: The ASN number associated with a legacy peering. Default value is None. :type asn: int :param direct_peering_type: The direct peering type. Known values are: "Edge", "Transit", - "Cdn", "Internal", "Ix", "IxRs", "Voice", and "EdgeZoneForOperators". Default value is None. + "Cdn", "Internal", "Ix", "IxRs", "Voice", "EdgeZoneForOperators", and "PeerProp". Default value + is None. :type direct_peering_type: str or ~azure.mgmt.peering.models.DirectPeeringType - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either Peering or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.Peering] :raises ~azure.core.exceptions.HttpResponseError: @@ -127,12 +122,10 @@ def list( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -143,19 +136,17 @@ def list( def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( subscription_id=self._config.subscription_id, peering_location=peering_location, kind=kind, asn=asn, direct_peering_type=direct_peering_type, api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -167,26 +158,26 @@ 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) # type: ignore - 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("PeeringListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -198,5 +189,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/legacyPeerings"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_looking_glass_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_looking_glass_operations.py index 2af46f69d4b7..b5cb7f6449cf 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_looking_glass_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_looking_glass_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,9 +5,10 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from collections.abc import MutableMapping from typing import Any, Callable, Dict, Optional, TypeVar, Union +from azure.core import PipelineClient from azure.core.exceptions import ( ClientAuthenticationError, HttpResponseError, @@ -18,20 +18,15 @@ map_error, ) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import HttpResponse -from azure.core.rest import HttpRequest +from azure.core.rest import HttpRequest, HttpResponse from azure.core.tracing.decorator import distributed_trace from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models -from .._serialization import Serializer -from .._vendor import PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -51,7 +46,7 @@ def build_invoke_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -60,7 +55,7 @@ def build_invoke_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["command"] = _SERIALIZER.query("command", command, "str") @@ -89,10 +84,10 @@ class LookingGlassOperations: 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: PeeringManagementClientConfiguration = 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 invoke( @@ -115,12 +110,11 @@ def invoke( :type source_location: str :param destination_ip: The IP address of the destination. Required. :type destination_ip: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: LookingGlassOutput or the result of cls(response) :rtype: ~azure.mgmt.peering.models.LookingGlassOutput :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -131,27 +125,24 @@ def invoke( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.LookingGlassOutput] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.LookingGlassOutput] = kwargs.pop("cls", None) - request = build_invoke_request( + _request = build_invoke_request( subscription_id=self._config.subscription_id, command=command, source_type=source_type, source_location=source_location, destination_ip=destination_ip, api_version=api_version, - template_url=self.invoke.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -161,11 +152,9 @@ def invoke( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("LookingGlassOutput", pipeline_response) + deserialized = self._deserialize("LookingGlassOutput", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - invoke.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/lookingGlass"} # type: ignore + return deserialized # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_operations.py index c2b4670c0fc5..e905c8a595c7 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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, @@ -20,20 +20,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -45,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 = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -74,16 +69,15 @@ 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: PeeringManagementClientConfiguration = 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"]: """Lists all of the available API operations for peering resources. - :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.peering.models.Operation] :raises ~azure.core.exceptions.HttpResponseError: @@ -91,12 +85,10 @@ def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] + 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, @@ -107,14 +99,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) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -126,26 +116,26 @@ 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) # type: ignore - 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) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -157,5 +147,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list.metadata = {"url": "/providers/Microsoft.Peering/operations"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peer_asns_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peer_asns_operations.py index efb780b22bd7..0e90bc8d3c45 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peer_asns_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peer_asns_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,12 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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,20 +21,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -45,7 +41,7 @@ def build_get_request(peer_asn_name: str, subscription_id: str, **kwargs: Any) - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -57,7 +53,7 @@ def build_get_request(peer_asn_name: str, subscription_id: str, **kwargs: Any) - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -72,8 +68,8 @@ def build_create_or_update_request(peer_asn_name: str, subscription_id: str, **k _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -85,7 +81,7 @@ def build_create_or_update_request(peer_asn_name: str, subscription_id: str, **k "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -102,7 +98,7 @@ def build_delete_request(peer_asn_name: str, subscription_id: str, **kwargs: Any _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -114,7 +110,7 @@ def build_delete_request(peer_asn_name: str, subscription_id: str, **kwargs: Any "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -129,7 +125,7 @@ def build_list_by_subscription_request(subscription_id: str, **kwargs: Any) -> H _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -138,7 +134,7 @@ def build_list_by_subscription_request(subscription_id: str, **kwargs: Any) -> H "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -163,10 +159,10 @@ class PeerAsnsOperations: 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: PeeringManagementClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace def get(self, peer_asn_name: str, **kwargs: Any) -> _models.PeerAsn: @@ -174,12 +170,11 @@ def get(self, peer_asn_name: str, **kwargs: Any) -> _models.PeerAsn: :param peer_asn_name: The peer ASN name. Required. :type peer_asn_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeerAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeerAsn :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -190,24 +185,21 @@ def get(self, peer_asn_name: str, **kwargs: Any) -> _models.PeerAsn: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeerAsn] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeerAsn] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( peer_asn_name=peer_asn_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -217,14 +209,12 @@ def get(self, peer_asn_name: str, **kwargs: Any) -> _models.PeerAsn: error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("PeerAsn", pipeline_response) + deserialized = self._deserialize("PeerAsn", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peerAsns/{peerAsnName}"} # type: ignore + return deserialized # type: ignore @overload def create_or_update( @@ -240,7 +230,6 @@ def create_or_update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeerAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeerAsn :raises ~azure.core.exceptions.HttpResponseError: @@ -248,7 +237,7 @@ def create_or_update( @overload def create_or_update( - self, peer_asn_name: str, peer_asn: IO, *, content_type: str = "application/json", **kwargs: Any + self, peer_asn_name: str, peer_asn: IO[bytes], *, content_type: str = "application/json", **kwargs: Any ) -> _models.PeerAsn: """Creates a new peer ASN or updates an existing peer ASN with the specified name under the given subscription. @@ -256,11 +245,10 @@ def create_or_update( :param peer_asn_name: The peer ASN name. Required. :type peer_asn_name: str :param peer_asn: The peer ASN. Required. - :type peer_asn: IO + :type peer_asn: 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: PeerAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeerAsn :raises ~azure.core.exceptions.HttpResponseError: @@ -268,24 +256,20 @@ def create_or_update( @distributed_trace def create_or_update( - self, peer_asn_name: str, peer_asn: Union[_models.PeerAsn, IO], **kwargs: Any + self, peer_asn_name: str, peer_asn: Union[_models.PeerAsn, IO[bytes]], **kwargs: Any ) -> _models.PeerAsn: """Creates a new peer ASN or updates an existing peer ASN with the specified name under the given subscription. :param peer_asn_name: The peer ASN name. Required. :type peer_asn_name: str - :param peer_asn: The peer ASN. Is either a model type or a IO type. Required. - :type peer_asn: ~azure.mgmt.peering.models.PeerAsn 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 peer_asn: The peer ASN. Is either a PeerAsn type or a IO[bytes] type. Required. + :type peer_asn: ~azure.mgmt.peering.models.PeerAsn or IO[bytes] :return: PeerAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeerAsn :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -296,36 +280,33 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeerAsn] + 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.PeerAsn] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(peer_asn, (IO, bytes)): + if isinstance(peer_asn, (IOBase, bytes)): _content = peer_asn else: _json = self._serialize.body(peer_asn, "PeerAsn") - request = build_create_or_update_request( + _request = build_create_or_update_request( peer_asn_name=peer_asn_name, subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -335,18 +316,12 @@ def create_or_update( 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("PeerAsn", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("PeerAsn", pipeline_response) + deserialized = self._deserialize("PeerAsn", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peerAsns/{peerAsnName}"} # type: ignore + return deserialized # type: ignore @distributed_trace def delete(self, peer_asn_name: str, **kwargs: Any) -> None: # pylint: disable=inconsistent-return-statements @@ -354,12 +329,11 @@ def delete(self, peer_asn_name: str, **kwargs: Any) -> None: # pylint: disable= :param peer_asn_name: The peer ASN name. Required. :type peer_asn_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, @@ -370,24 +344,21 @@ def delete(self, peer_asn_name: str, **kwargs: Any) -> None: # pylint: disable= _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + 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( peer_asn_name=peer_asn_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -398,15 +369,12 @@ def delete(self, peer_asn_name: str, **kwargs: Any) -> None: # pylint: disable= raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: - return cls(pipeline_response, None, {}) - - delete.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peerAsns/{peerAsnName}"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore @distributed_trace def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.PeerAsn"]: """Lists all of the peer ASNs under the given subscription. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeerAsn or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.PeerAsn] :raises ~azure.core.exceptions.HttpResponseError: @@ -414,12 +382,10 @@ def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.PeerAsn"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeerAsnListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeerAsnListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -430,15 +396,13 @@ def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.PeerAsn"]: 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) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -450,26 +414,26 @@ 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) # type: ignore - 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("PeerAsnListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -481,5 +445,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peerAsns"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_locations_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_locations_operations.py index b90176dcc921..89cd09f39d7d 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_locations_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_locations_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from collections.abc import MutableMapping from typing import Any, Callable, Dict, Iterable, Optional, TypeVar, Union import urllib.parse +from azure.core import PipelineClient from azure.core.exceptions import ( ClientAuthenticationError, HttpResponseError, @@ -20,20 +20,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -51,7 +46,7 @@ def build_list_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -60,7 +55,7 @@ def build_list_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["kind"] = _SERIALIZER.query("kind", kind, "str") @@ -88,10 +83,10 @@ class PeeringLocationsOperations: 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: PeeringManagementClientConfiguration = 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( @@ -105,9 +100,9 @@ def list( :param kind: The kind of the peering. Known values are: "Direct" and "Exchange". Required. :type kind: str or ~azure.mgmt.peering.models.PeeringLocationsKind :param direct_peering_type: The type of direct peering. Known values are: "Edge", "Transit", - "Cdn", "Internal", "Ix", "IxRs", "Voice", and "EdgeZoneForOperators". Default value is None. + "Cdn", "Internal", "Ix", "IxRs", "Voice", "EdgeZoneForOperators", and "PeerProp". Default value + is None. :type direct_peering_type: str or ~azure.mgmt.peering.models.PeeringLocationsDirectPeeringType - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringLocation or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.PeeringLocation] :raises ~azure.core.exceptions.HttpResponseError: @@ -115,12 +110,10 @@ def list( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringLocationListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringLocationListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -131,17 +124,15 @@ def list( def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( subscription_id=self._config.subscription_id, kind=kind, direct_peering_type=direct_peering_type, api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -153,26 +144,26 @@ 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) # type: ignore - 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("PeeringLocationListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -184,5 +175,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peeringLocations"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_management_client_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_management_client_operations.py index b5a8202c5aeb..de733bade25e 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_management_client_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_management_client_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. # -------------------------------------------------------------------------- -import sys +from collections.abc import MutableMapping +from io import IOBase from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload +from azure.core import PipelineClient from azure.core.exceptions import ( ClientAuthenticationError, HttpResponseError, @@ -18,20 +19,16 @@ map_error, ) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import HttpResponse -from azure.core.rest import HttpRequest +from azure.core.rest import HttpRequest, HttpResponse from azure.core.tracing.decorator import distributed_trace from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models -from .._serialization import Serializer -from .._vendor import PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Serializer +from .._utils.utils import ClientMixinABC -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -39,23 +36,25 @@ _SERIALIZER.client_side_validation = False -def build_check_service_provider_availability_request(subscription_id: str, **kwargs: Any) -> HttpRequest: +def build_check_service_provider_availability_request( # pylint: disable=name-too-long + subscription_id: str, **kwargs: Any +) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/checkServiceProviderAvailability" - ) # pylint: disable=line-too-long + ) path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -68,7 +67,8 @@ def build_check_service_provider_availability_request(subscription_id: str, **kw return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) -class PeeringManagementClientOperationsMixin(PeeringManagementClientMixinABC): +class PeeringManagementClientOperationsMixin(ClientMixinABC[PipelineClient, PeeringManagementClientConfiguration]): + @overload def check_service_provider_availability( self, @@ -86,7 +86,6 @@ def check_service_provider_availability( :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: Enum0 or the result of cls(response) :rtype: str or ~azure.mgmt.peering.models.Enum0 :raises ~azure.core.exceptions.HttpResponseError: @@ -94,17 +93,20 @@ def check_service_provider_availability( @overload def check_service_provider_availability( - self, check_service_provider_availability_input: IO, *, content_type: str = "application/json", **kwargs: Any + self, + check_service_provider_availability_input: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any ) -> Union[str, _models.Enum0]: """Checks if the peering service provider is present within 1000 miles of customer's location. :param check_service_provider_availability_input: The CheckServiceProviderAvailabilityInput indicating customer location and service provider. Required. - :type check_service_provider_availability_input: IO + :type check_service_provider_availability_input: 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: Enum0 or the result of cls(response) :rtype: str or ~azure.mgmt.peering.models.Enum0 :raises ~azure.core.exceptions.HttpResponseError: @@ -113,25 +115,21 @@ def check_service_provider_availability( @distributed_trace def check_service_provider_availability( self, - check_service_provider_availability_input: Union[_models.CheckServiceProviderAvailabilityInput, IO], + check_service_provider_availability_input: Union[_models.CheckServiceProviderAvailabilityInput, IO[bytes]], **kwargs: Any ) -> Union[str, _models.Enum0]: """Checks if the peering service provider is present within 1000 miles of customer's location. :param check_service_provider_availability_input: The CheckServiceProviderAvailabilityInput - indicating customer location and service provider. Is either a model type or a IO type. - Required. + indicating customer location and service provider. Is either a + CheckServiceProviderAvailabilityInput type or a IO[bytes] type. Required. :type check_service_provider_availability_input: - ~azure.mgmt.peering.models.CheckServiceProviderAvailabilityInput 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.peering.models.CheckServiceProviderAvailabilityInput or IO[bytes] :return: Enum0 or the result of cls(response) :rtype: str or ~azure.mgmt.peering.models.Enum0 :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -142,37 +140,34 @@ def check_service_provider_availability( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[Union[str, _models.Enum0]] + 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[Union[str, _models.Enum0]] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(check_service_provider_availability_input, (IO, bytes)): + if isinstance(check_service_provider_availability_input, (IOBase, bytes)): _content = check_service_provider_availability_input else: _json = self._serialize.body( check_service_provider_availability_input, "CheckServiceProviderAvailabilityInput" ) - request = build_check_service_provider_availability_request( + _request = build_check_service_provider_availability_request( subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, json=_json, content=_content, - template_url=self.check_service_provider_availability.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -182,11 +177,9 @@ def check_service_provider_availability( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("str", pipeline_response) + deserialized = self._deserialize("str", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - check_service_provider_availability.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/checkServiceProviderAvailability"} # type: ignore + return deserialized # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_service_countries_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_service_countries_operations.py index 99ca672237f8..836e389a9285 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_service_countries_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_service_countries_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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, @@ -20,20 +20,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -45,7 +40,7 @@ def build_list_request(subscription_id: str, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -56,7 +51,7 @@ def build_list_request(subscription_id: str, **kwargs: Any) -> HttpRequest: "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -81,16 +76,15 @@ class PeeringServiceCountriesOperations: 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: PeeringManagementClientConfiguration = 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.PeeringServiceCountry"]: """Lists all of the available countries for peering service. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringServiceCountry or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.PeeringServiceCountry] @@ -99,12 +93,10 @@ def list(self, **kwargs: Any) -> Iterable["_models.PeeringServiceCountry"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServiceCountryListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringServiceCountryListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -115,15 +107,13 @@ def list(self, **kwargs: Any) -> Iterable["_models.PeeringServiceCountry"]: def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -135,26 +125,26 @@ 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) # type: ignore - 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("PeeringServiceCountryListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -166,5 +156,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peeringServiceCountries"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_service_locations_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_service_locations_operations.py index 7c3fd9ab488f..0ea0236941f8 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_service_locations_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_service_locations_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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, @@ -20,20 +20,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -45,7 +40,7 @@ def build_list_request(subscription_id: str, *, country: Optional[str] = None, * _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -56,7 +51,7 @@ def build_list_request(subscription_id: str, *, country: Optional[str] = None, * "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters if country is not None: @@ -83,10 +78,10 @@ class PeeringServiceLocationsOperations: 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: PeeringManagementClientConfiguration = 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, country: Optional[str] = None, **kwargs: Any) -> Iterable["_models.PeeringServiceLocation"]: @@ -95,7 +90,6 @@ def list(self, country: Optional[str] = None, **kwargs: Any) -> Iterable["_model :param country: The country of interest, in which the locations are to be present. Default value is None. :type country: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringServiceLocation or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.PeeringServiceLocation] @@ -104,12 +98,10 @@ def list(self, country: Optional[str] = None, **kwargs: Any) -> Iterable["_model _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServiceLocationListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringServiceLocationListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -120,16 +112,14 @@ def list(self, country: Optional[str] = None, **kwargs: Any) -> Iterable["_model def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( subscription_id=self._config.subscription_id, country=country, api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -141,26 +131,26 @@ 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) # type: ignore - 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("PeeringServiceLocationListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -172,5 +162,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peeringServiceLocations"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_service_providers_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_service_providers_operations.py index 4733ba0e1562..36467e7e8626 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_service_providers_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_service_providers_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,10 +5,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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, @@ -20,20 +20,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -45,7 +40,7 @@ def build_list_request(subscription_id: str, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -56,7 +51,7 @@ def build_list_request(subscription_id: str, **kwargs: Any) -> HttpRequest: "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -81,16 +76,15 @@ class PeeringServiceProvidersOperations: 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: PeeringManagementClientConfiguration = 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.PeeringServiceProvider"]: """Lists all of the available peering service locations for the specified kind of peering. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringServiceProvider or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.PeeringServiceProvider] @@ -99,12 +93,10 @@ def list(self, **kwargs: Any) -> Iterable["_models.PeeringServiceProvider"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServiceProviderListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringServiceProviderListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -115,15 +107,13 @@ def list(self, **kwargs: Any) -> Iterable["_models.PeeringServiceProvider"]: def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -135,26 +125,26 @@ 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) # type: ignore - 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("PeeringServiceProviderListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -166,5 +156,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peeringServiceProviders"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_services_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_services_operations.py index 3e6069062833..99016b1c16d3 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_services_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peering_services_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. # -------------------------------------------------------------------------- -import sys +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,20 +22,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -47,21 +44,21 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringServiceName": _SERIALIZER.url("peering_service_name", peering_service_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -78,22 +75,22 @@ def build_create_or_update_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) + 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.Peering/peeringServices/{peeringServiceName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringServiceName": _SERIALIZER.url("peering_service_name", peering_service_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -112,21 +109,21 @@ def build_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringServiceName": _SERIALIZER.url("peering_service_name", peering_service_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -143,22 +140,22 @@ def build_update_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) + 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.Peering/peeringServices/{peeringServiceName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringServiceName": _SERIALIZER.url("peering_service_name", peering_service_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -175,20 +172,20 @@ 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 = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -203,7 +200,7 @@ def build_list_by_subscription_request(subscription_id: str, **kwargs: Any) -> H _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -212,7 +209,7 @@ def build_list_by_subscription_request(subscription_id: str, **kwargs: Any) -> H "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -223,22 +220,24 @@ def build_list_by_subscription_request(subscription_id: str, **kwargs: Any) -> H return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_initialize_connection_monitor_request(subscription_id: str, **kwargs: Any) -> HttpRequest: +def build_initialize_connection_monitor_request( # pylint: disable=name-too-long + subscription_id: str, **kwargs: Any +) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/initializeConnectionMonitor" - ) # pylint: disable=line-too-long + ) path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -263,10 +262,10 @@ class PeeringServicesOperations: 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: PeeringManagementClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace def get(self, resource_group_name: str, peering_service_name: str, **kwargs: Any) -> _models.PeeringService: @@ -277,12 +276,11 @@ def get(self, resource_group_name: str, peering_service_name: str, **kwargs: Any :type resource_group_name: str :param peering_service_name: The name of the peering. Required. :type peering_service_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringService or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringService :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -293,25 +291,22 @@ def get(self, resource_group_name: str, peering_service_name: str, **kwargs: Any _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringService] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringService] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, peering_service_name=peering_service_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -321,14 +316,12 @@ def get(self, resource_group_name: str, peering_service_name: str, **kwargs: Any error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("PeeringService", pipeline_response) + deserialized = self._deserialize("PeeringService", 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.Peering/peeringServices/{peeringServiceName}"} # type: ignore + return deserialized # type: ignore @overload def create_or_update( @@ -352,7 +345,6 @@ def create_or_update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringService or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringService :raises ~azure.core.exceptions.HttpResponseError: @@ -363,7 +355,7 @@ def create_or_update( self, resource_group_name: str, peering_service_name: str, - peering_service: IO, + peering_service: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -376,11 +368,10 @@ def create_or_update( :param peering_service_name: The name of the peering service. Required. :type peering_service_name: str :param peering_service: The properties needed to create or update a peering service. Required. - :type peering_service: IO + :type peering_service: 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: PeeringService or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringService :raises ~azure.core.exceptions.HttpResponseError: @@ -391,7 +382,7 @@ def create_or_update( self, resource_group_name: str, peering_service_name: str, - peering_service: Union[_models.PeeringService, IO], + peering_service: Union[_models.PeeringService, IO[bytes]], **kwargs: Any ) -> _models.PeeringService: """Creates a new peering service or updates an existing peering with the specified name under the @@ -402,17 +393,13 @@ def create_or_update( :param peering_service_name: The name of the peering service. Required. :type peering_service_name: str :param peering_service: The properties needed to create or update a peering service. Is either - a model type or a IO type. Required. - :type peering_service: ~azure.mgmt.peering.models.PeeringService 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 + a PeeringService type or a IO[bytes] type. Required. + :type peering_service: ~azure.mgmt.peering.models.PeeringService or IO[bytes] :return: PeeringService or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringService :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -423,21 +410,19 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringService] + 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.PeeringService] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(peering_service, (IO, bytes)): + if isinstance(peering_service, (IOBase, bytes)): _content = peering_service else: _json = self._serialize.body(peering_service, "PeeringService") - request = build_create_or_update_request( + _request = build_create_or_update_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, subscription_id=self._config.subscription_id, @@ -445,15 +430,14 @@ def create_or_update( content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -463,18 +447,12 @@ def create_or_update( 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("PeeringService", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("PeeringService", pipeline_response) + deserialized = self._deserialize("PeeringService", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}"} # type: ignore + return deserialized # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -487,12 +465,11 @@ def delete( # pylint: disable=inconsistent-return-statements :type resource_group_name: str :param peering_service_name: The name of the peering service. Required. :type peering_service_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, @@ -503,25 +480,22 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + 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, peering_service_name=peering_service_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -532,9 +506,7 @@ 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.Peering/peeringServices/{peeringServiceName}"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore @overload def update( @@ -558,7 +530,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: PeeringService or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringService :raises ~azure.core.exceptions.HttpResponseError: @@ -569,7 +540,7 @@ def update( self, resource_group_name: str, peering_service_name: str, - tags: IO, + tags: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -582,11 +553,10 @@ def update( :param peering_service_name: The name of the peering service. Required. :type peering_service_name: str :param tags: The resource tags. Required. - :type tags: IO + :type tags: 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: PeeringService or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringService :raises ~azure.core.exceptions.HttpResponseError: @@ -594,7 +564,11 @@ def update( @distributed_trace def update( - self, resource_group_name: str, peering_service_name: str, tags: Union[_models.ResourceTags, IO], **kwargs: Any + self, + resource_group_name: str, + peering_service_name: str, + tags: Union[_models.ResourceTags, IO[bytes]], + **kwargs: Any ) -> _models.PeeringService: """Updates tags for a peering service with the specified name under the given subscription and resource group. @@ -603,17 +577,13 @@ def update( :type resource_group_name: str :param peering_service_name: The name of the peering service. Required. :type peering_service_name: str - :param tags: The resource tags. Is either a model type or a IO type. Required. - :type tags: ~azure.mgmt.peering.models.ResourceTags 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 tags: The resource tags. Is either a ResourceTags type or a IO[bytes] type. Required. + :type tags: ~azure.mgmt.peering.models.ResourceTags or IO[bytes] :return: PeeringService or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringService :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -624,21 +594,19 @@ def update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringService] + 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.PeeringService] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(tags, (IO, bytes)): + if isinstance(tags, (IOBase, bytes)): _content = tags else: _json = self._serialize.body(tags, "ResourceTags") - request = build_update_request( + _request = build_update_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, subscription_id=self._config.subscription_id, @@ -646,15 +614,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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -664,14 +631,12 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("PeeringService", pipeline_response) + deserialized = self._deserialize("PeeringService", 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.Peering/peeringServices/{peeringServiceName}"} # type: ignore + return deserialized # type: ignore @distributed_trace def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Iterable["_models.PeeringService"]: @@ -679,7 +644,6 @@ def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Ite :param resource_group_name: The name of the resource group. 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 PeeringService or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.PeeringService] :raises ~azure.core.exceptions.HttpResponseError: @@ -687,12 +651,10 @@ def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Ite _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServiceListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringServiceListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -703,16 +665,14 @@ def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Ite 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) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -724,26 +684,26 @@ 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) # type: ignore - 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("PeeringServiceListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -756,13 +716,10 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices"} # type: ignore - @distributed_trace def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.PeeringService"]: """Lists all of the peerings under the given subscription. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringService or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.PeeringService] :raises ~azure.core.exceptions.HttpResponseError: @@ -770,12 +727,10 @@ def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.PeeringServic _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServiceListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringServiceListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -786,15 +741,13 @@ def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.PeeringServic 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) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -806,26 +759,26 @@ 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) # type: ignore - 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("PeeringServiceListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -838,18 +791,15 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peeringServices"} # type: ignore - @distributed_trace def initialize_connection_monitor(self, **kwargs: Any) -> None: # pylint: disable=inconsistent-return-statements """Initialize Peering Service for Connection Monitor functionality. - :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, @@ -860,23 +810,20 @@ def initialize_connection_monitor(self, **kwargs: Any) -> None: # pylint: disab _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[None] = kwargs.pop("cls", None) - request = build_initialize_connection_monitor_request( + _request = build_initialize_connection_monitor_request( subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.initialize_connection_monitor.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -887,6 +834,4 @@ def initialize_connection_monitor(self, **kwargs: Any) -> None: # pylint: disab raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: - return cls(pipeline_response, None, {}) - - initialize_connection_monitor.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/initializeConnectionMonitor"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peerings_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peerings_operations.py index 79da4c544859..41573b650a2f 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peerings_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_peerings_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. # -------------------------------------------------------------------------- -import sys +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,20 +22,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -45,21 +42,21 @@ def build_get_request(resource_group_name: str, peering_name: str, subscription_ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringName": _SERIALIZER.url("peering_name", peering_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -76,22 +73,22 @@ def build_create_or_update_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) + 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.Peering/peerings/{peeringName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringName": _SERIALIZER.url("peering_name", peering_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -110,21 +107,21 @@ def build_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringName": _SERIALIZER.url("peering_name", peering_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -141,22 +138,22 @@ def build_update_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) + 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.Peering/peerings/{peeringName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringName": _SERIALIZER.url("peering_name", peering_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -173,20 +170,20 @@ 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 = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -201,7 +198,7 @@ def build_list_by_subscription_request(subscription_id: str, **kwargs: Any) -> H _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -210,7 +207,7 @@ def build_list_by_subscription_request(subscription_id: str, **kwargs: Any) -> H "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -235,10 +232,10 @@ class PeeringsOperations: 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: PeeringManagementClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace def get(self, resource_group_name: str, peering_name: str, **kwargs: Any) -> _models.Peering: @@ -249,12 +246,11 @@ def get(self, resource_group_name: str, peering_name: str, **kwargs: Any) -> _mo :type resource_group_name: str :param peering_name: The name of the peering. Required. :type peering_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: Peering or the result of cls(response) :rtype: ~azure.mgmt.peering.models.Peering :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -265,25 +261,22 @@ def get(self, resource_group_name: str, peering_name: str, **kwargs: Any) -> _mo _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.Peering] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.Peering] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, peering_name=peering_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -293,14 +286,12 @@ def get(self, resource_group_name: str, peering_name: str, **kwargs: Any) -> _mo error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("Peering", pipeline_response) + deserialized = self._deserialize("Peering", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}"} # type: ignore + return deserialized # type: ignore @overload def create_or_update( @@ -324,7 +315,6 @@ def create_or_update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: Peering or the result of cls(response) :rtype: ~azure.mgmt.peering.models.Peering :raises ~azure.core.exceptions.HttpResponseError: @@ -335,7 +325,7 @@ def create_or_update( self, resource_group_name: str, peering_name: str, - peering: IO, + peering: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -348,11 +338,10 @@ def create_or_update( :param peering_name: The name of the peering. Required. :type peering_name: str :param peering: The properties needed to create or update a peering. Required. - :type peering: IO + :type peering: 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: Peering or the result of cls(response) :rtype: ~azure.mgmt.peering.models.Peering :raises ~azure.core.exceptions.HttpResponseError: @@ -360,7 +349,7 @@ def create_or_update( @distributed_trace def create_or_update( - self, resource_group_name: str, peering_name: str, peering: Union[_models.Peering, IO], **kwargs: Any + self, resource_group_name: str, peering_name: str, peering: Union[_models.Peering, IO[bytes]], **kwargs: Any ) -> _models.Peering: """Creates a new peering or updates an existing peering with the specified name under the given subscription and resource group. @@ -369,18 +358,14 @@ def create_or_update( :type resource_group_name: str :param peering_name: The name of the peering. Required. :type peering_name: str - :param peering: The properties needed to create or update a peering. Is either a model type or - a IO type. Required. - :type peering: ~azure.mgmt.peering.models.Peering 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 peering: The properties needed to create or update a peering. Is either a Peering type + or a IO[bytes] type. Required. + :type peering: ~azure.mgmt.peering.models.Peering or IO[bytes] :return: Peering or the result of cls(response) :rtype: ~azure.mgmt.peering.models.Peering :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -391,21 +376,19 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.Peering] + 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.Peering] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(peering, (IO, bytes)): + if isinstance(peering, (IOBase, bytes)): _content = peering else: _json = self._serialize.body(peering, "Peering") - request = build_create_or_update_request( + _request = build_create_or_update_request( resource_group_name=resource_group_name, peering_name=peering_name, subscription_id=self._config.subscription_id, @@ -413,15 +396,14 @@ def create_or_update( content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -431,18 +413,12 @@ def create_or_update( 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("Peering", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("Peering", pipeline_response) + deserialized = self._deserialize("Peering", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}"} # type: ignore + return deserialized # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -455,12 +431,11 @@ def delete( # pylint: disable=inconsistent-return-statements :type resource_group_name: str :param peering_name: The name of the peering. Required. :type peering_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, @@ -471,25 +446,22 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + 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, peering_name=peering_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -500,9 +472,7 @@ 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.Peering/peerings/{peeringName}"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore @overload def update( @@ -526,7 +496,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: Peering or the result of cls(response) :rtype: ~azure.mgmt.peering.models.Peering :raises ~azure.core.exceptions.HttpResponseError: @@ -537,7 +506,7 @@ def update( self, resource_group_name: str, peering_name: str, - tags: IO, + tags: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -550,11 +519,10 @@ def update( :param peering_name: The name of the peering. Required. :type peering_name: str :param tags: The resource tags. Required. - :type tags: IO + :type tags: 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: Peering or the result of cls(response) :rtype: ~azure.mgmt.peering.models.Peering :raises ~azure.core.exceptions.HttpResponseError: @@ -562,7 +530,7 @@ def update( @distributed_trace def update( - self, resource_group_name: str, peering_name: str, tags: Union[_models.ResourceTags, IO], **kwargs: Any + self, resource_group_name: str, peering_name: str, tags: Union[_models.ResourceTags, IO[bytes]], **kwargs: Any ) -> _models.Peering: """Updates tags for a peering with the specified name under the given subscription and resource group. @@ -571,17 +539,13 @@ def update( :type resource_group_name: str :param peering_name: The name of the peering. Required. :type peering_name: str - :param tags: The resource tags. Is either a model type or a IO type. Required. - :type tags: ~azure.mgmt.peering.models.ResourceTags 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 tags: The resource tags. Is either a ResourceTags type or a IO[bytes] type. Required. + :type tags: ~azure.mgmt.peering.models.ResourceTags or IO[bytes] :return: Peering or the result of cls(response) :rtype: ~azure.mgmt.peering.models.Peering :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -592,21 +556,19 @@ def update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.Peering] + 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.Peering] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(tags, (IO, bytes)): + if isinstance(tags, (IOBase, bytes)): _content = tags else: _json = self._serialize.body(tags, "ResourceTags") - request = build_update_request( + _request = build_update_request( resource_group_name=resource_group_name, peering_name=peering_name, subscription_id=self._config.subscription_id, @@ -614,15 +576,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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -632,14 +593,12 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("Peering", pipeline_response) + deserialized = self._deserialize("Peering", 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.Peering/peerings/{peeringName}"} # type: ignore + return deserialized # type: ignore @distributed_trace def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Iterable["_models.Peering"]: @@ -647,7 +606,6 @@ def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Ite :param resource_group_name: The name of the resource group. 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 Peering or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.Peering] :raises ~azure.core.exceptions.HttpResponseError: @@ -655,12 +613,10 @@ def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Ite _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -671,16 +627,14 @@ def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Ite 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) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -692,26 +646,26 @@ 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) # type: ignore - 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("PeeringListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -724,13 +678,10 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings"} # type: ignore - @distributed_trace def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.Peering"]: """Lists all of the peerings under the given subscription. - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either Peering or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.Peering] :raises ~azure.core.exceptions.HttpResponseError: @@ -738,12 +689,10 @@ def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.Peering"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -754,15 +703,13 @@ def list_by_subscription(self, **kwargs: Any) -> Iterable["_models.Peering"]: 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) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -774,26 +721,26 @@ 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) # type: ignore - 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("PeeringListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -805,5 +752,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Peering/peerings"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_prefixes_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_prefixes_operations.py index 2c2b37cad585..870ad0d66263 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_prefixes_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_prefixes_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. # -------------------------------------------------------------------------- -import sys +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,20 +22,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -53,14 +50,14 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/prefixes/{prefixName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringServiceName": _SERIALIZER.url("peering_service_name", peering_service_name, "str"), @@ -68,7 +65,7 @@ def build_get_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters if expand is not None: @@ -87,15 +84,15 @@ def build_create_or_update_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) + 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.Peering/peeringServices/{peeringServiceName}/prefixes/{prefixName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringServiceName": _SERIALIZER.url("peering_service_name", peering_service_name, "str"), @@ -103,7 +100,7 @@ def build_create_or_update_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -122,14 +119,14 @@ def build_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/prefixes/{prefixName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringServiceName": _SERIALIZER.url("peering_service_name", peering_service_name, "str"), @@ -137,7 +134,7 @@ def build_delete_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -159,21 +156,21 @@ def build_list_by_peering_service_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/prefixes", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringServiceName": _SERIALIZER.url("peering_service_name", peering_service_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters if expand is not None: @@ -200,10 +197,10 @@ class PrefixesOperations: 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: PeeringManagementClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace def get( @@ -225,12 +222,11 @@ def get( :type prefix_name: str :param expand: The properties to be expanded. Default value is None. :type expand: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringServicePrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringServicePrefix :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -241,27 +237,24 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServicePrefix] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringServicePrefix] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, prefix_name=prefix_name, subscription_id=self._config.subscription_id, expand=expand, api_version=api_version, - template_url=self.get.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -271,14 +264,12 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("PeeringServicePrefix", pipeline_response) + deserialized = self._deserialize("PeeringServicePrefix", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/prefixes/{prefixName}"} # type: ignore + return deserialized # type: ignore @overload def create_or_update( @@ -305,7 +296,6 @@ def create_or_update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringServicePrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringServicePrefix :raises ~azure.core.exceptions.HttpResponseError: @@ -317,7 +307,7 @@ def create_or_update( resource_group_name: str, peering_service_name: str, prefix_name: str, - peering_service_prefix: IO, + peering_service_prefix: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -332,11 +322,10 @@ def create_or_update( :param prefix_name: The name of the prefix. Required. :type prefix_name: str :param peering_service_prefix: The properties needed to create a prefix. Required. - :type peering_service_prefix: IO + :type peering_service_prefix: 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: PeeringServicePrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringServicePrefix :raises ~azure.core.exceptions.HttpResponseError: @@ -348,7 +337,7 @@ def create_or_update( resource_group_name: str, peering_service_name: str, prefix_name: str, - peering_service_prefix: Union[_models.PeeringServicePrefix, IO], + peering_service_prefix: Union[_models.PeeringServicePrefix, IO[bytes]], **kwargs: Any ) -> _models.PeeringServicePrefix: """Creates a new prefix with the specified name under the given subscription, resource group and @@ -360,18 +349,14 @@ def create_or_update( :type peering_service_name: str :param prefix_name: The name of the prefix. Required. :type prefix_name: str - :param peering_service_prefix: The properties needed to create a prefix. Is either a model type - or a IO type. Required. - :type peering_service_prefix: ~azure.mgmt.peering.models.PeeringServicePrefix 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 peering_service_prefix: The properties needed to create a prefix. Is either a + PeeringServicePrefix type or a IO[bytes] type. Required. + :type peering_service_prefix: ~azure.mgmt.peering.models.PeeringServicePrefix or IO[bytes] :return: PeeringServicePrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringServicePrefix :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -382,21 +367,19 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServicePrefix] + 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.PeeringServicePrefix] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(peering_service_prefix, (IO, bytes)): + if isinstance(peering_service_prefix, (IOBase, bytes)): _content = peering_service_prefix else: _json = self._serialize.body(peering_service_prefix, "PeeringServicePrefix") - request = build_create_or_update_request( + _request = build_create_or_update_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, prefix_name=prefix_name, @@ -405,15 +388,14 @@ def create_or_update( content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -423,18 +405,12 @@ def create_or_update( 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("PeeringServicePrefix", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("PeeringServicePrefix", pipeline_response) + deserialized = self._deserialize("PeeringServicePrefix", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/prefixes/{prefixName}"} # type: ignore + return deserialized # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -449,12 +425,11 @@ def delete( # pylint: disable=inconsistent-return-statements :type peering_service_name: str :param prefix_name: The name of the prefix. Required. :type prefix_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, @@ -465,26 +440,23 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + 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, peering_service_name=peering_service_name, prefix_name=prefix_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -495,9 +467,7 @@ 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.Peering/peeringServices/{peeringServiceName}/prefixes/{prefixName}"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore @distributed_trace def list_by_peering_service( @@ -511,7 +481,6 @@ def list_by_peering_service( :type peering_service_name: str :param expand: The properties to be expanded. Default value is None. :type expand: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringServicePrefix or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.PeeringServicePrefix] @@ -520,12 +489,10 @@ def list_by_peering_service( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringServicePrefixListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringServicePrefixListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -536,18 +503,16 @@ def list_by_peering_service( def prepare_request(next_link=None): if not next_link: - request = build_list_by_peering_service_request( + _request = build_list_by_peering_service_request( resource_group_name=resource_group_name, peering_service_name=peering_service_name, subscription_id=self._config.subscription_id, expand=expand, api_version=api_version, - template_url=self.list_by_peering_service.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -559,26 +524,26 @@ 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) # type: ignore - 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("PeeringServicePrefixListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -590,5 +555,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list_by_peering_service.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peeringServices/{peeringServiceName}/prefixes"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_received_routes_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_received_routes_operations.py index 49045fa25995..e702856dd249 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_received_routes_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_received_routes_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,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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, @@ -20,20 +21,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -56,21 +52,21 @@ def build_list_by_peering_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/receivedRoutes", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringName": _SERIALIZER.url("peering_name", peering_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters if prefix is not None: @@ -107,10 +103,10 @@ class ReceivedRoutesOperations: 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: PeeringManagementClientConfiguration = 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_peering( @@ -146,7 +142,6 @@ def list_by_peering( :param skip_token: The optional page continuation token that is used in the event of paginated result. Default value is None. :type skip_token: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringReceivedRoute or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.PeeringReceivedRoute] @@ -155,12 +150,10 @@ def list_by_peering( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringReceivedRouteListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringReceivedRouteListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -171,7 +164,7 @@ def list_by_peering( def prepare_request(next_link=None): if not next_link: - request = build_list_by_peering_request( + _request = build_list_by_peering_request( resource_group_name=resource_group_name, peering_name=peering_name, subscription_id=self._config.subscription_id, @@ -181,12 +174,10 @@ def prepare_request(next_link=None): rpki_validation_state=rpki_validation_state, skip_token=skip_token, api_version=api_version, - template_url=self.list_by_peering.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -198,26 +189,26 @@ 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) # type: ignore - 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("PeeringReceivedRouteListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -229,5 +220,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list_by_peering.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/receivedRoutes"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_registered_asns_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_registered_asns_operations.py index a8740a0e4617..ea6dde94703e 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_registered_asns_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_registered_asns_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. # -------------------------------------------------------------------------- -import sys +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,20 +22,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -47,14 +44,14 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredAsns/{registeredAsnName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringName": _SERIALIZER.url("peering_name", peering_name, "str"), @@ -62,7 +59,7 @@ def build_get_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -79,15 +76,15 @@ def build_create_or_update_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) + 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.Peering/peerings/{peeringName}/registeredAsns/{registeredAsnName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringName": _SERIALIZER.url("peering_name", peering_name, "str"), @@ -95,7 +92,7 @@ def build_create_or_update_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -114,14 +111,14 @@ def build_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredAsns/{registeredAsnName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringName": _SERIALIZER.url("peering_name", peering_name, "str"), @@ -129,7 +126,7 @@ def build_delete_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -146,21 +143,21 @@ def build_list_by_peering_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredAsns", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringName": _SERIALIZER.url("peering_name", peering_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -185,10 +182,10 @@ class RegisteredAsnsOperations: 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: PeeringManagementClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace def get( @@ -203,12 +200,11 @@ def get( :type peering_name: str :param registered_asn_name: The name of the registered ASN. Required. :type registered_asn_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringRegisteredAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredAsn :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -219,26 +215,23 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringRegisteredAsn] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringRegisteredAsn] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, peering_name=peering_name, registered_asn_name=registered_asn_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -248,14 +241,12 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("PeeringRegisteredAsn", pipeline_response) + deserialized = self._deserialize("PeeringRegisteredAsn", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredAsns/{registeredAsnName}"} # type: ignore + return deserialized # type: ignore @overload def create_or_update( @@ -282,7 +273,6 @@ def create_or_update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringRegisteredAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredAsn :raises ~azure.core.exceptions.HttpResponseError: @@ -294,7 +284,7 @@ def create_or_update( resource_group_name: str, peering_name: str, registered_asn_name: str, - registered_asn: IO, + registered_asn: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -309,11 +299,10 @@ def create_or_update( :param registered_asn_name: The name of the ASN. Required. :type registered_asn_name: str :param registered_asn: The properties needed to create a registered ASN. Required. - :type registered_asn: IO + :type registered_asn: 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: PeeringRegisteredAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredAsn :raises ~azure.core.exceptions.HttpResponseError: @@ -325,7 +314,7 @@ def create_or_update( resource_group_name: str, peering_name: str, registered_asn_name: str, - registered_asn: Union[_models.PeeringRegisteredAsn, IO], + registered_asn: Union[_models.PeeringRegisteredAsn, IO[bytes]], **kwargs: Any ) -> _models.PeeringRegisteredAsn: """Creates a new registered ASN with the specified name under the given subscription, resource @@ -337,18 +326,14 @@ def create_or_update( :type peering_name: str :param registered_asn_name: The name of the ASN. Required. :type registered_asn_name: str - :param registered_asn: The properties needed to create a registered ASN. Is either a model type - or a IO type. Required. - :type registered_asn: ~azure.mgmt.peering.models.PeeringRegisteredAsn 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 registered_asn: The properties needed to create a registered ASN. Is either a + PeeringRegisteredAsn type or a IO[bytes] type. Required. + :type registered_asn: ~azure.mgmt.peering.models.PeeringRegisteredAsn or IO[bytes] :return: PeeringRegisteredAsn or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredAsn :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -359,21 +344,19 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringRegisteredAsn] + 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.PeeringRegisteredAsn] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(registered_asn, (IO, bytes)): + if isinstance(registered_asn, (IOBase, bytes)): _content = registered_asn else: _json = self._serialize.body(registered_asn, "PeeringRegisteredAsn") - request = build_create_or_update_request( + _request = build_create_or_update_request( resource_group_name=resource_group_name, peering_name=peering_name, registered_asn_name=registered_asn_name, @@ -382,15 +365,14 @@ def create_or_update( content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -400,18 +382,12 @@ def create_or_update( 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("PeeringRegisteredAsn", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("PeeringRegisteredAsn", pipeline_response) + deserialized = self._deserialize("PeeringRegisteredAsn", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredAsns/{registeredAsnName}"} # type: ignore + return deserialized # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -426,12 +402,11 @@ def delete( # pylint: disable=inconsistent-return-statements :type peering_name: str :param registered_asn_name: The name of the registered ASN. Required. :type registered_asn_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, @@ -442,26 +417,23 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + 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, peering_name=peering_name, registered_asn_name=registered_asn_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -472,9 +444,7 @@ 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.Peering/peerings/{peeringName}/registeredAsns/{registeredAsnName}"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore @distributed_trace def list_by_peering( @@ -486,7 +456,6 @@ def list_by_peering( :type resource_group_name: str :param peering_name: The name of the peering. Required. :type peering_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringRegisteredAsn or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.PeeringRegisteredAsn] @@ -495,12 +464,10 @@ def list_by_peering( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringRegisteredAsnListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringRegisteredAsnListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -511,17 +478,15 @@ def list_by_peering( def prepare_request(next_link=None): if not next_link: - request = build_list_by_peering_request( + _request = build_list_by_peering_request( resource_group_name=resource_group_name, peering_name=peering_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_peering.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -533,26 +498,26 @@ 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) # type: ignore - 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("PeeringRegisteredAsnListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -564,5 +529,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list_by_peering.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredAsns"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_registered_prefixes_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_registered_prefixes_operations.py index 38bd0d6b50c4..00e030ca3181 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_registered_prefixes_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_registered_prefixes_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. # -------------------------------------------------------------------------- -import sys +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,20 +22,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -47,14 +44,14 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredPrefixes/{registeredPrefixName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringName": _SERIALIZER.url("peering_name", peering_name, "str"), @@ -62,7 +59,7 @@ def build_get_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -79,15 +76,15 @@ def build_create_or_update_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) + 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.Peering/peerings/{peeringName}/registeredPrefixes/{registeredPrefixName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringName": _SERIALIZER.url("peering_name", peering_name, "str"), @@ -95,7 +92,7 @@ def build_create_or_update_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -114,14 +111,14 @@ def build_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredPrefixes/{registeredPrefixName}", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringName": _SERIALIZER.url("peering_name", peering_name, "str"), @@ -129,7 +126,7 @@ def build_delete_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -146,21 +143,21 @@ def build_list_by_peering_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredPrefixes", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringName": _SERIALIZER.url("peering_name", peering_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -177,14 +174,14 @@ def build_validate_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredPrefixes/{registeredPrefixName}/validate", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringName": _SERIALIZER.url("peering_name", peering_name, "str"), @@ -192,7 +189,7 @@ def build_validate_request( "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -217,10 +214,10 @@ class RegisteredPrefixesOperations: 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: PeeringManagementClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace def get( @@ -235,12 +232,11 @@ def get( :type peering_name: str :param registered_prefix_name: The name of the registered prefix. Required. :type registered_prefix_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringRegisteredPrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredPrefix :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -251,26 +247,23 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringRegisteredPrefix] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringRegisteredPrefix] = kwargs.pop("cls", None) - request = build_get_request( + _request = build_get_request( resource_group_name=resource_group_name, peering_name=peering_name, registered_prefix_name=registered_prefix_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -280,14 +273,12 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("PeeringRegisteredPrefix", pipeline_response) + deserialized = self._deserialize("PeeringRegisteredPrefix", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) + return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredPrefixes/{registeredPrefixName}"} # type: ignore + return deserialized # type: ignore @overload def create_or_update( @@ -314,7 +305,6 @@ def create_or_update( :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringRegisteredPrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredPrefix :raises ~azure.core.exceptions.HttpResponseError: @@ -326,7 +316,7 @@ def create_or_update( resource_group_name: str, peering_name: str, registered_prefix_name: str, - registered_prefix: IO, + registered_prefix: IO[bytes], *, content_type: str = "application/json", **kwargs: Any @@ -341,11 +331,10 @@ def create_or_update( :param registered_prefix_name: The name of the registered prefix. Required. :type registered_prefix_name: str :param registered_prefix: The properties needed to create a registered prefix. Required. - :type registered_prefix: IO + :type registered_prefix: 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: PeeringRegisteredPrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredPrefix :raises ~azure.core.exceptions.HttpResponseError: @@ -357,7 +346,7 @@ def create_or_update( resource_group_name: str, peering_name: str, registered_prefix_name: str, - registered_prefix: Union[_models.PeeringRegisteredPrefix, IO], + registered_prefix: Union[_models.PeeringRegisteredPrefix, IO[bytes]], **kwargs: Any ) -> _models.PeeringRegisteredPrefix: """Creates a new registered prefix with the specified name under the given subscription, resource @@ -370,17 +359,13 @@ def create_or_update( :param registered_prefix_name: The name of the registered prefix. Required. :type registered_prefix_name: str :param registered_prefix: The properties needed to create a registered prefix. Is either a - model type or a IO type. Required. - :type registered_prefix: ~azure.mgmt.peering.models.PeeringRegisteredPrefix 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 + PeeringRegisteredPrefix type or a IO[bytes] type. Required. + :type registered_prefix: ~azure.mgmt.peering.models.PeeringRegisteredPrefix or IO[bytes] :return: PeeringRegisteredPrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredPrefix :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -391,21 +376,19 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringRegisteredPrefix] + 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.PeeringRegisteredPrefix] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None _content = None - if isinstance(registered_prefix, (IO, bytes)): + if isinstance(registered_prefix, (IOBase, bytes)): _content = registered_prefix else: _json = self._serialize.body(registered_prefix, "PeeringRegisteredPrefix") - request = build_create_or_update_request( + _request = build_create_or_update_request( resource_group_name=resource_group_name, peering_name=peering_name, registered_prefix_name=registered_prefix_name, @@ -414,15 +397,14 @@ def create_or_update( content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -432,18 +414,12 @@ def create_or_update( 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("PeeringRegisteredPrefix", pipeline_response) - - if response.status_code == 201: - deserialized = self._deserialize("PeeringRegisteredPrefix", pipeline_response) + deserialized = self._deserialize("PeeringRegisteredPrefix", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredPrefixes/{registeredPrefixName}"} # type: ignore + return deserialized # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -458,12 +434,11 @@ def delete( # pylint: disable=inconsistent-return-statements :type peering_name: str :param registered_prefix_name: The name of the registered prefix. Required. :type registered_prefix_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, @@ -474,26 +449,23 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + 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, peering_name=peering_name, registered_prefix_name=registered_prefix_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) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -504,9 +476,7 @@ 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.Peering/peerings/{peeringName}/registeredPrefixes/{registeredPrefixName}"} # type: ignore + return cls(pipeline_response, None, {}) # type: ignore @distributed_trace def list_by_peering( @@ -518,7 +488,6 @@ def list_by_peering( :type resource_group_name: str :param peering_name: The name of the peering. Required. :type peering_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PeeringRegisteredPrefix or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.PeeringRegisteredPrefix] @@ -527,12 +496,10 @@ def list_by_peering( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringRegisteredPrefixListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringRegisteredPrefixListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -543,17 +510,15 @@ def list_by_peering( def prepare_request(next_link=None): if not next_link: - request = build_list_by_peering_request( + _request = build_list_by_peering_request( resource_group_name=resource_group_name, peering_name=peering_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_peering.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -565,26 +530,26 @@ 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) # type: ignore - 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("PeeringRegisteredPrefixListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -597,8 +562,6 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_peering.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredPrefixes"} # type: ignore - @distributed_trace def validate( self, resource_group_name: str, peering_name: str, registered_prefix_name: str, **kwargs: Any @@ -612,12 +575,11 @@ def validate( :type peering_name: str :param registered_prefix_name: The name of the registered prefix. Required. :type registered_prefix_name: str - :keyword callable cls: A custom type or function that will be passed the direct response :return: PeeringRegisteredPrefix or the result of cls(response) :rtype: ~azure.mgmt.peering.models.PeeringRegisteredPrefix :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -628,26 +590,23 @@ def validate( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PeeringRegisteredPrefix] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.PeeringRegisteredPrefix] = kwargs.pop("cls", None) - request = build_validate_request( + _request = build_validate_request( resource_group_name=resource_group_name, peering_name=peering_name, registered_prefix_name=registered_prefix_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.validate.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -657,11 +616,9 @@ def validate( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize("PeeringRegisteredPrefix", pipeline_response) + deserialized = self._deserialize("PeeringRegisteredPrefix", pipeline_response.http_response) if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized + return cls(pipeline_response, deserialized, {}) # type: ignore - validate.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/registeredPrefixes/{registeredPrefixName}/validate"} # type: ignore + return deserialized # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_rp_unbilled_prefixes_operations.py b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_rp_unbilled_prefixes_operations.py index 2d86705672d2..a3c826295dcb 100644 --- a/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_rp_unbilled_prefixes_operations.py +++ b/sdk/peering/azure-mgmt-peering/azure/mgmt/peering/operations/_rp_unbilled_prefixes_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,11 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import sys +from 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, @@ -20,20 +21,15 @@ ) 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 PeeringManagementClientMixinABC, _convert_request, _format_url_section +from .._configuration import PeeringManagementClientConfiguration +from .._utils.serialization import Deserializer, Serializer -if sys.version_info >= (3, 8): - from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports -else: - from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] @@ -52,21 +48,21 @@ def build_list_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-10-01")) # type: Literal["2022-10-01"] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-05-01")) accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop( "template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/rpUnbilledPrefixes", - ) # pylint: disable=line-too-long + ) path_format_arguments = { "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), "peeringName": _SERIALIZER.url("peering_name", peering_name, "str"), "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _url.format(**path_format_arguments) # type: ignore # Construct parameters if consolidate is not None: @@ -93,10 +89,10 @@ class RpUnbilledPrefixesOperations: 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: PeeringManagementClientConfiguration = 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( @@ -110,7 +106,6 @@ def list( :type peering_name: str :param consolidate: Flag to enable consolidation prefixes. Default value is None. :type consolidate: bool - :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either RpUnbilledPrefix or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.peering.models.RpUnbilledPrefix] :raises ~azure.core.exceptions.HttpResponseError: @@ -118,12 +113,10 @@ def list( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( - "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2022-10-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.RpUnbilledPrefixListResult] + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + cls: ClsType[_models.RpUnbilledPrefixListResult] = kwargs.pop("cls", None) - error_map = { + error_map: MutableMapping = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, @@ -134,18 +127,16 @@ def list( def prepare_request(next_link=None): if not next_link: - request = build_list_request( + _request = build_list_request( resource_group_name=resource_group_name, peering_name=peering_name, subscription_id=self._config.subscription_id, consolidate=consolidate, api_version=api_version, - template_url=self.list.metadata["url"], headers=_headers, params=_params, ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + _request.url = self._client.format_url(_request.url) else: # make call to next link with the client's api-version @@ -157,26 +148,26 @@ 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) # type: ignore - 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("RpUnbilledPrefixListResult", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): - request = prepare_request(next_link) + _request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs ) response = pipeline_response.http_response @@ -188,5 +179,3 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) - - list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}/rpUnbilledPrefixes"} # type: ignore diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/check_if_peering_service_provider_is_available_in_customer_location.py b/sdk/peering/azure-mgmt-peering/generated_samples/check_service_provider_availability.py similarity index 90% rename from sdk/peering/azure-mgmt-peering/generated_samples/check_if_peering_service_provider_is_available_in_customer_location.py rename to sdk/peering/azure-mgmt-peering/generated_samples/check_service_provider_availability.py index 2efc125ed2cf..8c3e7a84e198 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/check_if_peering_service_provider_is_available_in_customer_location.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/check_service_provider_availability.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python check_if_peering_service_provider_is_available_in_customer_location.py + python check_service_provider_availability.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, @@ -38,6 +40,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/CheckServiceProviderAvailability.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/CheckServiceProviderAvailability.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/create_a_direct_peering.py b/sdk/peering/azure-mgmt-peering/generated_samples/create_direct_peering.py similarity index 94% rename from sdk/peering/azure-mgmt-peering/generated_samples/create_a_direct_peering.py rename to sdk/peering/azure-mgmt-peering/generated_samples/create_direct_peering.py index 47e28e3fd6fb..aacb919ed4d9 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/create_a_direct_peering.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/create_direct_peering.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python create_a_direct_peering.py + python create_direct_peering.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, @@ -36,6 +38,7 @@ def main(): "kind": "Direct", "location": "eastus", "properties": { + "connectivityProbes": [], "direct": { "connections": [ { @@ -71,6 +74,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/CreateDirectPeering.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/CreateDirectPeering.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/create_an_exchange_peering.py b/sdk/peering/azure-mgmt-peering/generated_samples/create_exchange_peering.py similarity index 94% rename from sdk/peering/azure-mgmt-peering/generated_samples/create_an_exchange_peering.py rename to sdk/peering/azure-mgmt-peering/generated_samples/create_exchange_peering.py index 509f5643867f..7ca2a71e1647 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/create_an_exchange_peering.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/create_exchange_peering.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python create_an_exchange_peering.py + python create_exchange_peering.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, @@ -36,6 +38,7 @@ def main(): "kind": "Exchange", "location": "eastus", "properties": { + "connectivityProbes": [], "exchange": { "connections": [ { @@ -71,6 +74,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/CreateExchangePeering.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/CreateExchangePeering.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/create_or_update_connection_monitor_test.py b/sdk/peering/azure-mgmt-peering/generated_samples/create_or_update_connection_monitor_test.py index 88b04ceab5fc..780ae6f4c210 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/create_or_update_connection_monitor_test.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/create_or_update_connection_monitor_test.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.peering import PeeringManagementClient """ @@ -45,6 +47,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/CreateOrUpdateConnectionMonitorTest.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/CreateOrUpdateConnectionMonitorTest.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/create_a_peer_asn.py b/sdk/peering/azure-mgmt-peering/generated_samples/create_peer_asn.py similarity index 92% rename from sdk/peering/azure-mgmt-peering/generated_samples/create_a_peer_asn.py rename to sdk/peering/azure-mgmt-peering/generated_samples/create_peer_asn.py index 0efa203fe5e1..4c5377fc73b4 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/create_a_peer_asn.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/create_peer_asn.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python create_a_peer_asn.py + python create_peer_asn.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, @@ -46,6 +48,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/CreatePeerAsn.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/CreatePeerAsn.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/create_a_peering_service.py b/sdk/peering/azure-mgmt-peering/generated_samples/create_peering_service.py similarity index 92% rename from sdk/peering/azure-mgmt-peering/generated_samples/create_a_peering_service.py rename to sdk/peering/azure-mgmt-peering/generated_samples/create_peering_service.py index c4fa05e59534..63f162619b0b 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/create_a_peering_service.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/create_peering_service.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python create_a_peering_service.py + python create_peering_service.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, @@ -45,6 +47,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/CreatePeeringService.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/CreatePeeringService.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/create_or_update_a_prefix_for_the_peering_service.py b/sdk/peering/azure-mgmt-peering/generated_samples/create_peering_service_prefix.py similarity index 91% rename from sdk/peering/azure-mgmt-peering/generated_samples/create_or_update_a_prefix_for_the_peering_service.py rename to sdk/peering/azure-mgmt-peering/generated_samples/create_peering_service_prefix.py index 7b00306d6acc..ddc3149ed4de 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/create_or_update_a_prefix_for_the_peering_service.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/create_peering_service_prefix.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python create_or_update_a_prefix_for_the_peering_service.py + python create_peering_service_prefix.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, @@ -43,6 +45,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/CreatePeeringServicePrefix.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/CreatePeeringServicePrefix.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/create_a_peering_with_exchange_route_server.py b/sdk/peering/azure-mgmt-peering/generated_samples/create_peering_with_exchange_route_server.py similarity index 92% rename from sdk/peering/azure-mgmt-peering/generated_samples/create_a_peering_with_exchange_route_server.py rename to sdk/peering/azure-mgmt-peering/generated_samples/create_peering_with_exchange_route_server.py index 34164bf59af8..7b2be71b6ecd 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/create_a_peering_with_exchange_route_server.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/create_peering_with_exchange_route_server.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python create_a_peering_with_exchange_route_server.py + python create_peering_with_exchange_route_server.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, @@ -36,6 +38,7 @@ def main(): "kind": "Direct", "location": "eastus", "properties": { + "connectivityProbes": [], "direct": { "connections": [ { @@ -64,6 +67,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/CreatePeeringWithExchangeRouteServer.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/CreatePeeringWithExchangeRouteServer.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/create_or_update_a_registered_asn_for_the_peering.py b/sdk/peering/azure-mgmt-peering/generated_samples/create_registered_asn.py similarity index 90% rename from sdk/peering/azure-mgmt-peering/generated_samples/create_or_update_a_registered_asn_for_the_peering.py rename to sdk/peering/azure-mgmt-peering/generated_samples/create_registered_asn.py index 82e245fa974c..d30b3ef5ebd9 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/create_or_update_a_registered_asn_for_the_peering.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/create_registered_asn.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python create_or_update_a_registered_asn_for_the_peering.py + python create_registered_asn.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, @@ -38,6 +40,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/CreateRegisteredAsn.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/CreateRegisteredAsn.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/create_or_update_a_registered_prefix_for_the_peering.py b/sdk/peering/azure-mgmt-peering/generated_samples/create_registered_prefix.py similarity index 90% rename from sdk/peering/azure-mgmt-peering/generated_samples/create_or_update_a_registered_prefix_for_the_peering.py rename to sdk/peering/azure-mgmt-peering/generated_samples/create_registered_prefix.py index 7bd3f05b15e1..de94934da612 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/create_or_update_a_registered_prefix_for_the_peering.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/create_registered_prefix.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python create_or_update_a_registered_prefix_for_the_peering.py + python create_registered_prefix.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, @@ -38,6 +40,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/CreateRegisteredPrefix.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/CreateRegisteredPrefix.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/delete_connection_monitor_test.py b/sdk/peering/azure-mgmt-peering/generated_samples/delete_connection_monitor_test.py index a8adb1c1f35e..a4ef5575b4b5 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/delete_connection_monitor_test.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/delete_connection_monitor_test.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.peering import PeeringManagementClient """ @@ -29,14 +31,13 @@ def main(): subscription_id="subId", ) - response = client.connection_monitor_tests.delete( + client.connection_monitor_tests.delete( resource_group_name="rgName", peering_service_name="peeringServiceName", connection_monitor_test_name="connectionMonitorTestName", ) - print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/DeleteConnectionMonitorTest.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/DeleteConnectionMonitorTest.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/delete_a_peer_asn.py b/sdk/peering/azure-mgmt-peering/generated_samples/delete_peer_asn.py similarity index 88% rename from sdk/peering/azure-mgmt-peering/generated_samples/delete_a_peer_asn.py rename to sdk/peering/azure-mgmt-peering/generated_samples/delete_peer_asn.py index 885d2ba0d532..7f184ded0cb5 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/delete_a_peer_asn.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/delete_peer_asn.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python delete_a_peer_asn.py + python delete_peer_asn.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, @@ -29,12 +31,11 @@ def main(): subscription_id="subId", ) - response = client.peer_asns.delete( + client.peer_asns.delete( peer_asn_name="peerAsnName", ) - print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/DeletePeerAsn.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/DeletePeerAsn.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/delete_a_peering.py b/sdk/peering/azure-mgmt-peering/generated_samples/delete_peering.py similarity index 88% rename from sdk/peering/azure-mgmt-peering/generated_samples/delete_a_peering.py rename to sdk/peering/azure-mgmt-peering/generated_samples/delete_peering.py index 4e7565cb20c1..81d9756c9be7 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/delete_a_peering.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/delete_peering.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python delete_a_peering.py + python delete_peering.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, @@ -29,13 +31,12 @@ def main(): subscription_id="subId", ) - response = client.peerings.delete( + client.peerings.delete( resource_group_name="rgName", peering_name="peeringName", ) - print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/DeletePeering.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/DeletePeering.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/delete_a_peering_service.py b/sdk/peering/azure-mgmt-peering/generated_samples/delete_peering_service.py similarity index 87% rename from sdk/peering/azure-mgmt-peering/generated_samples/delete_a_peering_service.py rename to sdk/peering/azure-mgmt-peering/generated_samples/delete_peering_service.py index 39defc38f23f..2365f5b8a567 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/delete_a_peering_service.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/delete_peering_service.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python delete_a_peering_service.py + python delete_peering_service.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, @@ -29,13 +31,12 @@ def main(): subscription_id="subId", ) - response = client.peering_services.delete( + client.peering_services.delete( resource_group_name="rgName", peering_service_name="peeringServiceName", ) - print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/DeletePeeringService.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/DeletePeeringService.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/delete_a_prefix_associated_with_the_peering_service.py b/sdk/peering/azure-mgmt-peering/generated_samples/delete_peering_service_prefix.py similarity index 88% rename from sdk/peering/azure-mgmt-peering/generated_samples/delete_a_prefix_associated_with_the_peering_service.py rename to sdk/peering/azure-mgmt-peering/generated_samples/delete_peering_service_prefix.py index 03c9f68991ac..27d5ce49787b 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/delete_a_prefix_associated_with_the_peering_service.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/delete_peering_service_prefix.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python delete_a_prefix_associated_with_the_peering_service.py + python delete_peering_service_prefix.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, @@ -29,14 +31,13 @@ def main(): subscription_id="subId", ) - response = client.prefixes.delete( + client.prefixes.delete( resource_group_name="rgName", peering_service_name="peeringServiceName", prefix_name="peeringServicePrefixName", ) - print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/DeletePeeringServicePrefix.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/DeletePeeringServicePrefix.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/deletes_a_registered_asn_associated_with_the_peering.py b/sdk/peering/azure-mgmt-peering/generated_samples/delete_registered_asn.py similarity index 87% rename from sdk/peering/azure-mgmt-peering/generated_samples/deletes_a_registered_asn_associated_with_the_peering.py rename to sdk/peering/azure-mgmt-peering/generated_samples/delete_registered_asn.py index cf171437a1ee..45f12dee4a4e 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/deletes_a_registered_asn_associated_with_the_peering.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/delete_registered_asn.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python deletes_a_registered_asn_associated_with_the_peering.py + python delete_registered_asn.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, @@ -29,14 +31,13 @@ def main(): subscription_id="subId", ) - response = client.registered_asns.delete( + client.registered_asns.delete( resource_group_name="rgName", peering_name="peeringName", registered_asn_name="registeredAsnName", ) - print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/DeleteRegisteredAsn.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/DeleteRegisteredAsn.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/deletes_a_registered_prefix_associated_with_the_peering.py b/sdk/peering/azure-mgmt-peering/generated_samples/delete_registered_prefix.py similarity index 87% rename from sdk/peering/azure-mgmt-peering/generated_samples/deletes_a_registered_prefix_associated_with_the_peering.py rename to sdk/peering/azure-mgmt-peering/generated_samples/delete_registered_prefix.py index 543cbfb7f910..c7aea3a6dc08 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/deletes_a_registered_prefix_associated_with_the_peering.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/delete_registered_prefix.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python deletes_a_registered_prefix_associated_with_the_peering.py + python delete_registered_prefix.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, @@ -29,14 +31,13 @@ def main(): subscription_id="subId", ) - response = client.registered_prefixes.delete( + client.registered_prefixes.delete( resource_group_name="rgName", peering_name="peeringName", registered_prefix_name="registeredPrefixName", ) - print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/DeleteRegisteredPrefix.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/DeleteRegisteredPrefix.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/get_connection_monitor_test.py b/sdk/peering/azure-mgmt-peering/generated_samples/get_connection_monitor_test.py index 3a7423ccf445..3f46d8c786a2 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/get_connection_monitor_test.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/get_connection_monitor_test.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.peering import PeeringManagementClient """ @@ -37,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/GetConnectionMonitorTest.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/GetConnectionMonitorTest.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/get_a_peer_asn.py b/sdk/peering/azure-mgmt-peering/generated_samples/get_peer_asn.py similarity index 90% rename from sdk/peering/azure-mgmt-peering/generated_samples/get_a_peer_asn.py rename to sdk/peering/azure-mgmt-peering/generated_samples/get_peer_asn.py index 9ce13c67c972..cae4aa40d659 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/get_a_peer_asn.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/get_peer_asn.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python get_a_peer_asn.py + python get_peer_asn.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, @@ -35,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/GetPeerAsn.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/GetPeerAsn.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/get_a_peering.py b/sdk/peering/azure-mgmt-peering/generated_samples/get_peering.py similarity index 91% rename from sdk/peering/azure-mgmt-peering/generated_samples/get_a_peering.py rename to sdk/peering/azure-mgmt-peering/generated_samples/get_peering.py index c037fb0e1bd8..25a83d3c5ff1 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/get_a_peering.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/get_peering.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python get_a_peering.py + python get_peering.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, @@ -36,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/GetPeering.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/GetPeering.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/lists_the_prefixes_received_over_the_specified_peering_under_the_given_subscription_and_resource_group..py b/sdk/peering/azure-mgmt-peering/generated_samples/get_peering_received_routes.py similarity index 88% rename from sdk/peering/azure-mgmt-peering/generated_samples/lists_the_prefixes_received_over_the_specified_peering_under_the_given_subscription_and_resource_group..py rename to sdk/peering/azure-mgmt-peering/generated_samples/get_peering_received_routes.py index 1c07f9d7f3a6..c7b56254651a 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/lists_the_prefixes_received_over_the_specified_peering_under_the_given_subscription_and_resource_group..py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/get_peering_received_routes.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python lists_the_prefixes_received_over_the_specified_peering_under_the_given_subscription_and_resource_group..py + python get_peering_received_routes.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, @@ -37,6 +39,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/GetPeeringReceivedRoutes.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/GetPeeringReceivedRoutes.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/get_a_peering_service.py b/sdk/peering/azure-mgmt-peering/generated_samples/get_peering_service.py similarity index 90% rename from sdk/peering/azure-mgmt-peering/generated_samples/get_a_peering_service.py rename to sdk/peering/azure-mgmt-peering/generated_samples/get_peering_service.py index 6b5ee0daa275..7f3088449fbd 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/get_a_peering_service.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/get_peering_service.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python get_a_peering_service.py + python get_peering_service.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, @@ -36,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/GetPeeringService.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/GetPeeringService.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/get_a_prefix_associated_with_the_peering_service.py b/sdk/peering/azure-mgmt-peering/generated_samples/get_peering_service_prefix.py similarity index 90% rename from sdk/peering/azure-mgmt-peering/generated_samples/get_a_prefix_associated_with_the_peering_service.py rename to sdk/peering/azure-mgmt-peering/generated_samples/get_peering_service_prefix.py index 90c5320f7562..3815d9f915ec 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/get_a_prefix_associated_with_the_peering_service.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/get_peering_service_prefix.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python get_a_prefix_associated_with_the_peering_service.py + python get_peering_service_prefix.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, @@ -37,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/GetPeeringServicePrefix.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/GetPeeringServicePrefix.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/get_a_registered_asn_associated_with_the_peering.py b/sdk/peering/azure-mgmt-peering/generated_samples/get_registered_asn.py similarity index 90% rename from sdk/peering/azure-mgmt-peering/generated_samples/get_a_registered_asn_associated_with_the_peering.py rename to sdk/peering/azure-mgmt-peering/generated_samples/get_registered_asn.py index fb5441af520d..8ec01f1af9be 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/get_a_registered_asn_associated_with_the_peering.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/get_registered_asn.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python get_a_registered_asn_associated_with_the_peering.py + python get_registered_asn.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, @@ -37,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/GetRegisteredAsn.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/GetRegisteredAsn.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/get_a_registered_prefix_associated_with_the_peering.py b/sdk/peering/azure-mgmt-peering/generated_samples/get_registered_prefix.py similarity index 90% rename from sdk/peering/azure-mgmt-peering/generated_samples/get_a_registered_prefix_associated_with_the_peering.py rename to sdk/peering/azure-mgmt-peering/generated_samples/get_registered_prefix.py index ed00d7c69155..9f4c4f747f79 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/get_a_registered_prefix_associated_with_the_peering.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/get_registered_prefix.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python get_a_registered_prefix_associated_with_the_peering.py + python get_registered_prefix.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, @@ -37,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/GetRegisteredPrefix.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/GetRegisteredPrefix.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/initialize_peering_service_for_connection_monitor_functionality.py b/sdk/peering/azure-mgmt-peering/generated_samples/initialize_connection_monitor.py similarity index 84% rename from sdk/peering/azure-mgmt-peering/generated_samples/initialize_peering_service_for_connection_monitor_functionality.py rename to sdk/peering/azure-mgmt-peering/generated_samples/initialize_connection_monitor.py index 1cabbd0d47c3..26ba10b239dd 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/initialize_peering_service_for_connection_monitor_functionality.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/initialize_connection_monitor.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python initialize_peering_service_for_connection_monitor_functionality.py + python initialize_connection_monitor.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, @@ -29,10 +31,9 @@ def main(): subscription_id="subId", ) - response = client.peering_services.initialize_connection_monitor() - print(response) + client.peering_services.initialize_connection_monitor() -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/InitializeConnectionMonitor.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/InitializeConnectionMonitor.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_all_the_cdn_peering_prefixes_advertised_at_a_particular_peering_location.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_cdn_peering_prefixes.py similarity index 90% rename from sdk/peering/azure-mgmt-peering/generated_samples/list_all_the_cdn_peering_prefixes_advertised_at_a_particular_peering_location.py rename to sdk/peering/azure-mgmt-peering/generated_samples/list_cdn_peering_prefixes.py index 69726c0e05b3..8151250916b0 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_all_the_cdn_peering_prefixes_advertised_at_a_particular_peering_location.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_cdn_peering_prefixes.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python list_all_the_cdn_peering_prefixes_advertised_at_a_particular_peering_location.py + python list_cdn_peering_prefixes.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, @@ -36,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListCdnPeeringPrefixes.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListCdnPeeringPrefixes.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_all_connection_monitor_tests_associated_with_the_peering_service.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_connection_monitor_tests_by_peering_service.py similarity index 89% rename from sdk/peering/azure-mgmt-peering/generated_samples/list_all_connection_monitor_tests_associated_with_the_peering_service.py rename to sdk/peering/azure-mgmt-peering/generated_samples/list_connection_monitor_tests_by_peering_service.py index 1885f2181792..baf9aa8ad13a 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_all_connection_monitor_tests_associated_with_the_peering_service.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_connection_monitor_tests_by_peering_service.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python list_all_connection_monitor_tests_associated_with_the_peering_service.py + python list_connection_monitor_tests_by_peering_service.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, @@ -37,6 +39,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListConnectionMonitorTestsByPeeringService.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListConnectionMonitorTestsByPeeringService.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_direct_peering_locations.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_direct_peering_locations.py index af1f551723ae..c1f25de1d435 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_direct_peering_locations.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_direct_peering_locations.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.peering import PeeringManagementClient """ @@ -36,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListDirectPeeringLocations.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListDirectPeeringLocations.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_exchange_peering_locations.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_exchange_peering_locations.py index 3567de4ba60d..a1c2796f227a 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_exchange_peering_locations.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_exchange_peering_locations.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.peering import PeeringManagementClient """ @@ -36,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListExchangePeeringLocations.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListExchangePeeringLocations.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_legacy_peerings.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_legacy_peerings.py index 954fecd5ef7e..b718384450ca 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_legacy_peerings.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_legacy_peerings.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.peering import PeeringManagementClient """ @@ -37,6 +39,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListLegacyPeerings.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListLegacyPeerings.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_peer_as_ns_in_a_subscription.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_peer_asns_by_subscription.py similarity index 89% rename from sdk/peering/azure-mgmt-peering/generated_samples/list_peer_as_ns_in_a_subscription.py rename to sdk/peering/azure-mgmt-peering/generated_samples/list_peer_asns_by_subscription.py index adb44974f42f..d7037bf549da 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_peer_as_ns_in_a_subscription.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_peer_asns_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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python list_peer_as_ns_in_a_subscription.py + python list_peer_asns_by_subscription.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, @@ -34,6 +36,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListPeerAsnsBySubscription.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListPeerAsnsBySubscription.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_operations.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_operations.py index f3ce267ea9b5..1c022290a09c 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_operations.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_operations.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.peering import PeeringManagementClient """ @@ -34,6 +36,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListPeeringOperations.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListPeeringOperations.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_countries.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_countries_by_subscription.py similarity index 88% rename from sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_countries.py rename to sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_countries_by_subscription.py index 9f78ec4a2f4b..8e705739149f 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_countries.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_countries_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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python list_peering_service_countries.py + python list_peering_service_countries_by_subscription.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, @@ -34,6 +36,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListPeeringServiceCountriesBySubscription.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListPeeringServiceCountriesBySubscription.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_locations.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_locations_by_subscription.py similarity index 88% rename from sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_locations.py rename to sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_locations_by_subscription.py index 69d75c3a44b4..1e121fba8045 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_locations.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_locations_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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python list_peering_service_locations.py + python list_peering_service_locations_by_subscription.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, @@ -34,6 +36,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListPeeringServiceLocationsBySubscription.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListPeeringServiceLocationsBySubscription.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_providers.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_providers.py index 38ce5268a4d7..14b72445b0c4 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_providers.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_service_providers.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.peering import PeeringManagementClient """ @@ -34,6 +36,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListPeeringServiceProviders.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListPeeringServiceProviders.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_services_in_a_resource_group.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_services_by_resource_group.py similarity index 89% rename from sdk/peering/azure-mgmt-peering/generated_samples/list_peering_services_in_a_resource_group.py rename to sdk/peering/azure-mgmt-peering/generated_samples/list_peering_services_by_resource_group.py index 287c2d129451..8859ce840867 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_services_in_a_resource_group.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_services_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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python list_peering_services_in_a_resource_group.py + python list_peering_services_by_resource_group.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, @@ -36,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListPeeringServicesByResourceGroup.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListPeeringServicesByResourceGroup.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_services_in_a_subscription.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_services_by_subscription.py similarity index 89% rename from sdk/peering/azure-mgmt-peering/generated_samples/list_peering_services_in_a_subscription.py rename to sdk/peering/azure-mgmt-peering/generated_samples/list_peering_services_by_subscription.py index 4e64c3c21925..a7cd4f8f1b4b 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_services_in_a_subscription.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_peering_services_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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python list_peering_services_in_a_subscription.py + python list_peering_services_by_subscription.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, @@ -34,6 +36,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListPeeringServicesBySubscription.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListPeeringServicesBySubscription.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_peerings_in_a_resource_group.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_peerings_by_resource_group.py similarity index 89% rename from sdk/peering/azure-mgmt-peering/generated_samples/list_peerings_in_a_resource_group.py rename to sdk/peering/azure-mgmt-peering/generated_samples/list_peerings_by_resource_group.py index bf7edec55eaf..4ff78620c551 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_peerings_in_a_resource_group.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_peerings_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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python list_peerings_in_a_resource_group.py + python list_peerings_by_resource_group.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, @@ -36,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListPeeringsByResourceGroup.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListPeeringsByResourceGroup.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_peerings_in_a_subscription.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_peerings_by_subscription.py similarity index 89% rename from sdk/peering/azure-mgmt-peering/generated_samples/list_peerings_in_a_subscription.py rename to sdk/peering/azure-mgmt-peering/generated_samples/list_peerings_by_subscription.py index 276267306b37..872e732a0ece 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_peerings_in_a_subscription.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_peerings_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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python list_peerings_in_a_subscription.py + python list_peerings_by_subscription.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, @@ -34,6 +36,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListPeeringsBySubscription.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListPeeringsBySubscription.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_all_the_prefixes_associated_with_the_peering_service.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_prefixes_by_peering_service.py similarity index 90% rename from sdk/peering/azure-mgmt-peering/generated_samples/list_all_the_prefixes_associated_with_the_peering_service.py rename to sdk/peering/azure-mgmt-peering/generated_samples/list_prefixes_by_peering_service.py index cc5bfb20e6dd..6a9c7ec03e0b 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_all_the_prefixes_associated_with_the_peering_service.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_prefixes_by_peering_service.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python list_all_the_prefixes_associated_with_the_peering_service.py + python list_prefixes_by_peering_service.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, @@ -37,6 +39,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListPrefixesByPeeringService.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListPrefixesByPeeringService.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_all_the_registered_as_ns_associated_with_the_peering.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_registered_asns_by_peering.py similarity index 90% rename from sdk/peering/azure-mgmt-peering/generated_samples/list_all_the_registered_as_ns_associated_with_the_peering.py rename to sdk/peering/azure-mgmt-peering/generated_samples/list_registered_asns_by_peering.py index ae702a79dca3..1a81c2c562f0 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_all_the_registered_as_ns_associated_with_the_peering.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_registered_asns_by_peering.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python list_all_the_registered_as_ns_associated_with_the_peering.py + python list_registered_asns_by_peering.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, @@ -37,6 +39,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListRegisteredAsnsByPeering.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListRegisteredAsnsByPeering.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_all_the_registered_prefixes_associated_with_the_peering.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_registered_prefixes_by_peering.py similarity index 89% rename from sdk/peering/azure-mgmt-peering/generated_samples/list_all_the_registered_prefixes_associated_with_the_peering.py rename to sdk/peering/azure-mgmt-peering/generated_samples/list_registered_prefixes_by_peering.py index 5128663b4312..153a53ca8825 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_all_the_registered_prefixes_associated_with_the_peering.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_registered_prefixes_by_peering.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python list_all_the_registered_prefixes_associated_with_the_peering.py + python list_registered_prefixes_by_peering.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, @@ -37,6 +39,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListRegisteredPrefixesByPeering.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListRegisteredPrefixesByPeering.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/list_all_the_rp_unbilled_prefixes_advertised_at_a_particular_peering_location.py b/sdk/peering/azure-mgmt-peering/generated_samples/list_rp_unbilled_prefixes.py similarity index 90% rename from sdk/peering/azure-mgmt-peering/generated_samples/list_all_the_rp_unbilled_prefixes_advertised_at_a_particular_peering_location.py rename to sdk/peering/azure-mgmt-peering/generated_samples/list_rp_unbilled_prefixes.py index a586e5d4ec5c..a51e74e98f0b 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/list_all_the_rp_unbilled_prefixes_advertised_at_a_particular_peering_location.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/list_rp_unbilled_prefixes.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python list_all_the_rp_unbilled_prefixes_advertised_at_a_particular_peering_location.py + python list_rp_unbilled_prefixes.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, @@ -37,6 +39,6 @@ def main(): print(item) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ListRpUnbilledPrefixes.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ListRpUnbilledPrefixes.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/call_looking_glass_to_execute_a_command.py b/sdk/peering/azure-mgmt-peering/generated_samples/looking_glass_invoke_command.py similarity index 90% rename from sdk/peering/azure-mgmt-peering/generated_samples/call_looking_glass_to_execute_a_command.py rename to sdk/peering/azure-mgmt-peering/generated_samples/looking_glass_invoke_command.py index 8cb93e209ae6..362c1a8c7576 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/call_looking_glass_to_execute_a_command.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/looking_glass_invoke_command.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python call_looking_glass_to_execute_a_command.py + python looking_glass_invoke_command.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, @@ -38,6 +40,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/LookingGlassInvokeCommand.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/LookingGlassInvokeCommand.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/update_peering_service_tags.py b/sdk/peering/azure-mgmt-peering/generated_samples/update_peering_service_tags.py index 4967f7ecb8a5..647163de95e8 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/update_peering_service_tags.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/update_peering_service_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.peering import PeeringManagementClient """ @@ -37,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/UpdatePeeringServiceTags.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/UpdatePeeringServiceTags.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/update_peering_tags.py b/sdk/peering/azure-mgmt-peering/generated_samples/update_peering_tags.py index 2fd6c8ab5f02..203883802fdd 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/update_peering_tags.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/update_peering_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.peering import PeeringManagementClient """ @@ -37,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/UpdatePeeringTags.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/UpdatePeeringTags.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_samples/validate_a_registered_prefix_associated_with_the_peering.py b/sdk/peering/azure-mgmt-peering/generated_samples/validate_registered_prefix.py similarity index 90% rename from sdk/peering/azure-mgmt-peering/generated_samples/validate_a_registered_prefix_associated_with_the_peering.py rename to sdk/peering/azure-mgmt-peering/generated_samples/validate_registered_prefix.py index 53e8e4c5c0f7..5337146bf3b8 100644 --- a/sdk/peering/azure-mgmt-peering/generated_samples/validate_a_registered_prefix_associated_with_the_peering.py +++ b/sdk/peering/azure-mgmt-peering/generated_samples/validate_registered_prefix.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.peering import PeeringManagementClient """ @@ -14,7 +16,7 @@ pip install azure-identity pip install azure-mgmt-peering # USAGE - python validate_a_registered_prefix_associated_with_the_peering.py + python validate_registered_prefix.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, @@ -37,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2022-10-01/examples/ValidateRegisteredPrefix.json +# x-ms-original-file: specification/peering/resource-manager/Microsoft.Peering/stable/2025-05-01/examples/ValidateRegisteredPrefix.json if __name__ == "__main__": main() diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/conftest.py b/sdk/peering/azure-mgmt-peering/generated_tests/conftest.py new file mode 100644 index 000000000000..72c0695e138d --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/conftest.py @@ -0,0 +1,35 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import os +import pytest +from dotenv import load_dotenv +from devtools_testutils import ( + test_proxy, + add_general_regex_sanitizer, + add_body_key_sanitizer, + add_header_regex_sanitizer, +) + +load_dotenv() + + +# For security, please avoid record sensitive identity information in recordings +@pytest.fixture(scope="session", autouse=True) +def add_sanitizers(test_proxy): + peeringmanagement_subscription_id = os.environ.get("AZURE_SUBSCRIPTION_ID", "00000000-0000-0000-0000-000000000000") + peeringmanagement_tenant_id = os.environ.get("AZURE_TENANT_ID", "00000000-0000-0000-0000-000000000000") + peeringmanagement_client_id = os.environ.get("AZURE_CLIENT_ID", "00000000-0000-0000-0000-000000000000") + peeringmanagement_client_secret = os.environ.get("AZURE_CLIENT_SECRET", "00000000-0000-0000-0000-000000000000") + add_general_regex_sanitizer(regex=peeringmanagement_subscription_id, value="00000000-0000-0000-0000-000000000000") + add_general_regex_sanitizer(regex=peeringmanagement_tenant_id, value="00000000-0000-0000-0000-000000000000") + add_general_regex_sanitizer(regex=peeringmanagement_client_id, value="00000000-0000-0000-0000-000000000000") + add_general_regex_sanitizer(regex=peeringmanagement_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/peering/azure-mgmt-peering/generated_tests/test_peering_management.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management.py new file mode 100644 index 000000000000..6d60483af893 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management.py @@ -0,0 +1,33 @@ +# 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.peering import PeeringManagementClient + +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 TestPeeringManagement(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_check_service_provider_availability(self, resource_group): + response = self.client.check_service_provider_availability( + check_service_provider_availability_input={ + "peeringServiceLocation": "str", + "peeringServiceProvider": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_async.py new file mode 100644 index 000000000000..02eae8c8cbcb --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_async.py @@ -0,0 +1,34 @@ +# 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.peering.aio import PeeringManagementClient + +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 TestPeeringManagementAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_check_service_provider_availability(self, resource_group): + response = await self.client.check_service_provider_availability( + check_service_provider_availability_input={ + "peeringServiceLocation": "str", + "peeringServiceProvider": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_cdn_peering_prefixes_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_cdn_peering_prefixes_operations.py new file mode 100644 index 000000000000..e1505bd8d200 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_cdn_peering_prefixes_operations.py @@ -0,0 +1,30 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.peering import PeeringManagementClient + +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 TestPeeringManagementCdnPeeringPrefixesOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_cdn_peering_prefixes_list(self, resource_group): + response = self.client.cdn_peering_prefixes.list( + peering_location="str", + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_cdn_peering_prefixes_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_cdn_peering_prefixes_operations_async.py new file mode 100644 index 000000000000..d73c38c87e64 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_cdn_peering_prefixes_operations_async.py @@ -0,0 +1,31 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.peering.aio import PeeringManagementClient + +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 TestPeeringManagementCdnPeeringPrefixesOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_cdn_peering_prefixes_list(self, resource_group): + response = self.client.cdn_peering_prefixes.list( + peering_location="str", + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_connection_monitor_tests_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_connection_monitor_tests_operations.py new file mode 100644 index 000000000000..3cd10ebd0ecc --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_connection_monitor_tests_operations.py @@ -0,0 +1,82 @@ +# 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.peering import PeeringManagementClient + +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 TestPeeringManagementConnectionMonitorTestsOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_connection_monitor_tests_get(self, resource_group): + response = self.client.connection_monitor_tests.get( + resource_group_name=resource_group.name, + peering_service_name="str", + connection_monitor_test_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_connection_monitor_tests_create_or_update(self, resource_group): + response = self.client.connection_monitor_tests.create_or_update( + resource_group_name=resource_group.name, + peering_service_name="str", + connection_monitor_test_name="str", + connection_monitor_test={ + "destination": "str", + "destinationPort": 0, + "id": "str", + "isTestSuccessful": bool, + "name": "str", + "path": ["str"], + "provisioningState": "str", + "sourceAgent": "str", + "testFrequencyInSec": 0, + "type": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_connection_monitor_tests_delete(self, resource_group): + response = self.client.connection_monitor_tests.delete( + resource_group_name=resource_group.name, + peering_service_name="str", + connection_monitor_test_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_connection_monitor_tests_list_by_peering_service(self, resource_group): + response = self.client.connection_monitor_tests.list_by_peering_service( + resource_group_name=resource_group.name, + peering_service_name="str", + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_connection_monitor_tests_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_connection_monitor_tests_operations_async.py new file mode 100644 index 000000000000..1aab68a851fe --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_connection_monitor_tests_operations_async.py @@ -0,0 +1,83 @@ +# 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.peering.aio import PeeringManagementClient + +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 TestPeeringManagementConnectionMonitorTestsOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_connection_monitor_tests_get(self, resource_group): + response = await self.client.connection_monitor_tests.get( + resource_group_name=resource_group.name, + peering_service_name="str", + connection_monitor_test_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_connection_monitor_tests_create_or_update(self, resource_group): + response = await self.client.connection_monitor_tests.create_or_update( + resource_group_name=resource_group.name, + peering_service_name="str", + connection_monitor_test_name="str", + connection_monitor_test={ + "destination": "str", + "destinationPort": 0, + "id": "str", + "isTestSuccessful": bool, + "name": "str", + "path": ["str"], + "provisioningState": "str", + "sourceAgent": "str", + "testFrequencyInSec": 0, + "type": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_connection_monitor_tests_delete(self, resource_group): + response = await self.client.connection_monitor_tests.delete( + resource_group_name=resource_group.name, + peering_service_name="str", + connection_monitor_test_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_connection_monitor_tests_list_by_peering_service(self, resource_group): + response = self.client.connection_monitor_tests.list_by_peering_service( + resource_group_name=resource_group.name, + peering_service_name="str", + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_legacy_peerings_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_legacy_peerings_operations.py new file mode 100644 index 000000000000..c054984688c5 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_legacy_peerings_operations.py @@ -0,0 +1,31 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.peering import PeeringManagementClient + +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 TestPeeringManagementLegacyPeeringsOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_legacy_peerings_list(self, resource_group): + response = self.client.legacy_peerings.list( + peering_location="str", + kind="str", + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_legacy_peerings_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_legacy_peerings_operations_async.py new file mode 100644 index 000000000000..767acd467bb7 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_legacy_peerings_operations_async.py @@ -0,0 +1,32 @@ +# 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.peering.aio import PeeringManagementClient + +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 TestPeeringManagementLegacyPeeringsOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_legacy_peerings_list(self, resource_group): + response = self.client.legacy_peerings.list( + peering_location="str", + kind="str", + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_looking_glass_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_looking_glass_operations.py new file mode 100644 index 000000000000..76ff2a6d834b --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_looking_glass_operations.py @@ -0,0 +1,33 @@ +# 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.peering import PeeringManagementClient + +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 TestPeeringManagementLookingGlassOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_looking_glass_invoke(self, resource_group): + response = self.client.looking_glass.invoke( + command="str", + source_type="str", + source_location="str", + destination_ip="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_looking_glass_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_looking_glass_operations_async.py new file mode 100644 index 000000000000..caeeccbd7d26 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_looking_glass_operations_async.py @@ -0,0 +1,34 @@ +# 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.peering.aio import PeeringManagementClient + +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 TestPeeringManagementLookingGlassOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_looking_glass_invoke(self, resource_group): + response = await self.client.looking_glass.invoke( + command="str", + source_type="str", + source_location="str", + destination_ip="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_operations.py new file mode 100644 index 000000000000..abd7f06d5146 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_operations.py @@ -0,0 +1,29 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.peering import PeeringManagementClient + +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 TestPeeringManagementOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_operations_list(self, resource_group): + response = self.client.operations.list( + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_operations_async.py new file mode 100644 index 000000000000..6c94bdf787ad --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_operations_async.py @@ -0,0 +1,30 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.peering.aio import PeeringManagementClient + +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 TestPeeringManagementOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_operations_list(self, resource_group): + response = self.client.operations.list( + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peer_asns_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peer_asns_operations.py new file mode 100644 index 000000000000..b58cdb30a397 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peer_asns_operations.py @@ -0,0 +1,72 @@ +# 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.peering import PeeringManagementClient + +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 TestPeeringManagementPeerAsnsOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peer_asns_get(self, resource_group): + response = self.client.peer_asns.get( + peer_asn_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peer_asns_create_or_update(self, resource_group): + response = self.client.peer_asns.create_or_update( + peer_asn_name="str", + peer_asn={ + "errorMessage": "str", + "id": "str", + "name": "str", + "peerAsn": 0, + "peerContactDetail": [{"email": "str", "phone": "str", "role": "str"}], + "peerName": "str", + "type": "str", + "validationState": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peer_asns_delete(self, resource_group): + response = self.client.peer_asns.delete( + peer_asn_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peer_asns_list_by_subscription(self, resource_group): + response = self.client.peer_asns.list_by_subscription( + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peer_asns_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peer_asns_operations_async.py new file mode 100644 index 000000000000..9a4f52bfb050 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peer_asns_operations_async.py @@ -0,0 +1,73 @@ +# 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.peering.aio import PeeringManagementClient + +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 TestPeeringManagementPeerAsnsOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peer_asns_get(self, resource_group): + response = await self.client.peer_asns.get( + peer_asn_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peer_asns_create_or_update(self, resource_group): + response = await self.client.peer_asns.create_or_update( + peer_asn_name="str", + peer_asn={ + "errorMessage": "str", + "id": "str", + "name": "str", + "peerAsn": 0, + "peerContactDetail": [{"email": "str", "phone": "str", "role": "str"}], + "peerName": "str", + "type": "str", + "validationState": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peer_asns_delete(self, resource_group): + response = await self.client.peer_asns.delete( + peer_asn_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peer_asns_list_by_subscription(self, resource_group): + response = self.client.peer_asns.list_by_subscription( + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_locations_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_locations_operations.py new file mode 100644 index 000000000000..bf682b7a639e --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_locations_operations.py @@ -0,0 +1,30 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.peering import PeeringManagementClient + +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 TestPeeringManagementPeeringLocationsOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peering_locations_list(self, resource_group): + response = self.client.peering_locations.list( + kind="str", + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_locations_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_locations_operations_async.py new file mode 100644 index 000000000000..cd4ae23d00d6 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_locations_operations_async.py @@ -0,0 +1,31 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.peering.aio import PeeringManagementClient + +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 TestPeeringManagementPeeringLocationsOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peering_locations_list(self, resource_group): + response = self.client.peering_locations.list( + kind="str", + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_countries_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_countries_operations.py new file mode 100644 index 000000000000..24468d9a5322 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_countries_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.peering import PeeringManagementClient + +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 TestPeeringManagementPeeringServiceCountriesOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peering_service_countries_list(self, resource_group): + response = self.client.peering_service_countries.list( + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_countries_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_countries_operations_async.py new file mode 100644 index 000000000000..00c5e2677359 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_countries_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.peering.aio import PeeringManagementClient + +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 TestPeeringManagementPeeringServiceCountriesOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peering_service_countries_list(self, resource_group): + response = self.client.peering_service_countries.list( + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_locations_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_locations_operations.py new file mode 100644 index 000000000000..bc814f823058 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_locations_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.peering import PeeringManagementClient + +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 TestPeeringManagementPeeringServiceLocationsOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peering_service_locations_list(self, resource_group): + response = self.client.peering_service_locations.list( + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_locations_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_locations_operations_async.py new file mode 100644 index 000000000000..f77d933ca929 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_locations_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.peering.aio import PeeringManagementClient + +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 TestPeeringManagementPeeringServiceLocationsOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peering_service_locations_list(self, resource_group): + response = self.client.peering_service_locations.list( + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_providers_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_providers_operations.py new file mode 100644 index 000000000000..f9fee40fd7e8 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_providers_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.peering import PeeringManagementClient + +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 TestPeeringManagementPeeringServiceProvidersOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peering_service_providers_list(self, resource_group): + response = self.client.peering_service_providers.list( + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_providers_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_providers_operations_async.py new file mode 100644 index 000000000000..50ce5ddaf001 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_service_providers_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.peering.aio import PeeringManagementClient + +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 TestPeeringManagementPeeringServiceProvidersOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peering_service_providers_list(self, resource_group): + response = self.client.peering_service_providers.list( + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_services_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_services_operations.py new file mode 100644 index 000000000000..beb20c286989 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_services_operations.py @@ -0,0 +1,113 @@ +# 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.peering import PeeringManagementClient + +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 TestPeeringManagementPeeringServicesOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peering_services_get(self, resource_group): + response = self.client.peering_services.get( + resource_group_name=resource_group.name, + peering_service_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peering_services_create_or_update(self, resource_group): + response = self.client.peering_services.create_or_update( + resource_group_name=resource_group.name, + peering_service_name="str", + peering_service={ + "location": "str", + "id": "str", + "logAnalyticsWorkspaceProperties": {"connectedAgents": ["str"], "key": "str", "workspaceID": "str"}, + "name": "str", + "peeringServiceLocation": "str", + "peeringServiceProvider": "str", + "providerBackupPeeringLocation": "str", + "providerPrimaryPeeringLocation": "str", + "provisioningState": "str", + "sku": {"name": "str"}, + "tags": {"str": "str"}, + "type": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peering_services_delete(self, resource_group): + response = self.client.peering_services.delete( + resource_group_name=resource_group.name, + peering_service_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peering_services_update(self, resource_group): + response = self.client.peering_services.update( + resource_group_name=resource_group.name, + peering_service_name="str", + tags={"tags": {"str": "str"}}, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peering_services_list_by_resource_group(self, resource_group): + response = self.client.peering_services.list_by_resource_group( + resource_group_name=resource_group.name, + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peering_services_list_by_subscription(self, resource_group): + response = self.client.peering_services.list_by_subscription( + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peering_services_initialize_connection_monitor(self, resource_group): + response = self.client.peering_services.initialize_connection_monitor( + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_services_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_services_operations_async.py new file mode 100644 index 000000000000..071ec0fb6a7f --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peering_services_operations_async.py @@ -0,0 +1,114 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.peering.aio import PeeringManagementClient + +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 TestPeeringManagementPeeringServicesOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peering_services_get(self, resource_group): + response = await self.client.peering_services.get( + resource_group_name=resource_group.name, + peering_service_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peering_services_create_or_update(self, resource_group): + response = await self.client.peering_services.create_or_update( + resource_group_name=resource_group.name, + peering_service_name="str", + peering_service={ + "location": "str", + "id": "str", + "logAnalyticsWorkspaceProperties": {"connectedAgents": ["str"], "key": "str", "workspaceID": "str"}, + "name": "str", + "peeringServiceLocation": "str", + "peeringServiceProvider": "str", + "providerBackupPeeringLocation": "str", + "providerPrimaryPeeringLocation": "str", + "provisioningState": "str", + "sku": {"name": "str"}, + "tags": {"str": "str"}, + "type": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peering_services_delete(self, resource_group): + response = await self.client.peering_services.delete( + resource_group_name=resource_group.name, + peering_service_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peering_services_update(self, resource_group): + response = await self.client.peering_services.update( + resource_group_name=resource_group.name, + peering_service_name="str", + tags={"tags": {"str": "str"}}, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peering_services_list_by_resource_group(self, resource_group): + response = self.client.peering_services.list_by_resource_group( + resource_group_name=resource_group.name, + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peering_services_list_by_subscription(self, resource_group): + response = self.client.peering_services.list_by_subscription( + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peering_services_initialize_connection_monitor(self, resource_group): + response = await self.client.peering_services.initialize_connection_monitor( + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peerings_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peerings_operations.py new file mode 100644 index 000000000000..73bae66e9006 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peerings_operations.py @@ -0,0 +1,172 @@ +# 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.peering import PeeringManagementClient + +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 TestPeeringManagementPeeringsOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peerings_get(self, resource_group): + response = self.client.peerings.get( + resource_group_name=resource_group.name, + peering_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peerings_create_or_update(self, resource_group): + response = self.client.peerings.create_or_update( + resource_group_name=resource_group.name, + peering_name="str", + peering={ + "kind": "str", + "location": "str", + "sku": {"family": "str", "name": "str", "size": "str", "tier": "str"}, + "connectivityProbes": [ + { + "azureRegion": "str", + "createdTimeUtc": "2020-02-20 00:00:00", + "endpoint": "str", + "prefixesToAccesslist": ["str"], + "protocol": "str", + } + ], + "direct": { + "connections": [ + { + "bandwidthInMbps": 0, + "bgpSession": { + "maxPrefixesAdvertisedV4": 0, + "maxPrefixesAdvertisedV6": 0, + "md5AuthenticationKey": "str", + "microsoftSessionIPv4Address": "str", + "microsoftSessionIPv6Address": "str", + "peerSessionIPv4Address": "str", + "peerSessionIPv6Address": "str", + "sessionPrefixV4": "str", + "sessionPrefixV6": "str", + "sessionStateV4": "str", + "sessionStateV6": "str", + }, + "connectionIdentifier": "str", + "connectionState": "str", + "errorMessage": "str", + "lastFailureTimeUtc": "2020-02-20 00:00:00", + "microsoftTrackingId": "str", + "migrationWorkWindowBgpSessionSameDevice": {"str": "str"}, + "migrationWorkWindowTracker": "str", + "peeringDBFacilityId": 0, + "previousConnectionProvisioningState": "str", + "provisionedBandwidthInMbps": 0, + "sessionAddressProvider": "str", + "useForPeeringService": bool, + } + ], + "directPeeringType": "str", + "peerAsn": {"id": "str"}, + "useForPeeringService": bool, + }, + "exchange": { + "connections": [ + { + "bgpSession": { + "maxPrefixesAdvertisedV4": 0, + "maxPrefixesAdvertisedV6": 0, + "md5AuthenticationKey": "str", + "microsoftSessionIPv4Address": "str", + "microsoftSessionIPv6Address": "str", + "peerSessionIPv4Address": "str", + "peerSessionIPv6Address": "str", + "sessionPrefixV4": "str", + "sessionPrefixV6": "str", + "sessionStateV4": "str", + "sessionStateV6": "str", + }, + "connectionIdentifier": "str", + "connectionState": "str", + "errorMessage": "str", + "lastFailureTimeUtc": "2020-02-20 00:00:00", + "migrationWorkWindowBgpSessionSameDevice": {"str": "str"}, + "migrationWorkWindowTracker": "str", + "peeringDBFacilityId": 0, + "previousConnectionProvisioningState": "str", + } + ], + "peerAsn": {"id": "str"}, + }, + "id": "str", + "name": "str", + "peeringLocation": "str", + "provisioningState": "str", + "tags": {"str": "str"}, + "type": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peerings_delete(self, resource_group): + response = self.client.peerings.delete( + resource_group_name=resource_group.name, + peering_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peerings_update(self, resource_group): + response = self.client.peerings.update( + resource_group_name=resource_group.name, + peering_name="str", + tags={"tags": {"str": "str"}}, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peerings_list_by_resource_group(self, resource_group): + response = self.client.peerings.list_by_resource_group( + resource_group_name=resource_group.name, + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_peerings_list_by_subscription(self, resource_group): + response = self.client.peerings.list_by_subscription( + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peerings_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peerings_operations_async.py new file mode 100644 index 000000000000..c50123032ca6 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_peerings_operations_async.py @@ -0,0 +1,173 @@ +# 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.peering.aio import PeeringManagementClient + +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 TestPeeringManagementPeeringsOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peerings_get(self, resource_group): + response = await self.client.peerings.get( + resource_group_name=resource_group.name, + peering_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peerings_create_or_update(self, resource_group): + response = await self.client.peerings.create_or_update( + resource_group_name=resource_group.name, + peering_name="str", + peering={ + "kind": "str", + "location": "str", + "sku": {"family": "str", "name": "str", "size": "str", "tier": "str"}, + "connectivityProbes": [ + { + "azureRegion": "str", + "createdTimeUtc": "2020-02-20 00:00:00", + "endpoint": "str", + "prefixesToAccesslist": ["str"], + "protocol": "str", + } + ], + "direct": { + "connections": [ + { + "bandwidthInMbps": 0, + "bgpSession": { + "maxPrefixesAdvertisedV4": 0, + "maxPrefixesAdvertisedV6": 0, + "md5AuthenticationKey": "str", + "microsoftSessionIPv4Address": "str", + "microsoftSessionIPv6Address": "str", + "peerSessionIPv4Address": "str", + "peerSessionIPv6Address": "str", + "sessionPrefixV4": "str", + "sessionPrefixV6": "str", + "sessionStateV4": "str", + "sessionStateV6": "str", + }, + "connectionIdentifier": "str", + "connectionState": "str", + "errorMessage": "str", + "lastFailureTimeUtc": "2020-02-20 00:00:00", + "microsoftTrackingId": "str", + "migrationWorkWindowBgpSessionSameDevice": {"str": "str"}, + "migrationWorkWindowTracker": "str", + "peeringDBFacilityId": 0, + "previousConnectionProvisioningState": "str", + "provisionedBandwidthInMbps": 0, + "sessionAddressProvider": "str", + "useForPeeringService": bool, + } + ], + "directPeeringType": "str", + "peerAsn": {"id": "str"}, + "useForPeeringService": bool, + }, + "exchange": { + "connections": [ + { + "bgpSession": { + "maxPrefixesAdvertisedV4": 0, + "maxPrefixesAdvertisedV6": 0, + "md5AuthenticationKey": "str", + "microsoftSessionIPv4Address": "str", + "microsoftSessionIPv6Address": "str", + "peerSessionIPv4Address": "str", + "peerSessionIPv6Address": "str", + "sessionPrefixV4": "str", + "sessionPrefixV6": "str", + "sessionStateV4": "str", + "sessionStateV6": "str", + }, + "connectionIdentifier": "str", + "connectionState": "str", + "errorMessage": "str", + "lastFailureTimeUtc": "2020-02-20 00:00:00", + "migrationWorkWindowBgpSessionSameDevice": {"str": "str"}, + "migrationWorkWindowTracker": "str", + "peeringDBFacilityId": 0, + "previousConnectionProvisioningState": "str", + } + ], + "peerAsn": {"id": "str"}, + }, + "id": "str", + "name": "str", + "peeringLocation": "str", + "provisioningState": "str", + "tags": {"str": "str"}, + "type": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peerings_delete(self, resource_group): + response = await self.client.peerings.delete( + resource_group_name=resource_group.name, + peering_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peerings_update(self, resource_group): + response = await self.client.peerings.update( + resource_group_name=resource_group.name, + peering_name="str", + tags={"tags": {"str": "str"}}, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peerings_list_by_resource_group(self, resource_group): + response = self.client.peerings.list_by_resource_group( + resource_group_name=resource_group.name, + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_peerings_list_by_subscription(self, resource_group): + response = self.client.peerings.list_by_subscription( + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_prefixes_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_prefixes_operations.py new file mode 100644 index 000000000000..9ca13a14cc09 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_prefixes_operations.py @@ -0,0 +1,90 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.peering import PeeringManagementClient + +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 TestPeeringManagementPrefixesOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_prefixes_get(self, resource_group): + response = self.client.prefixes.get( + resource_group_name=resource_group.name, + peering_service_name="str", + prefix_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_prefixes_create_or_update(self, resource_group): + response = self.client.prefixes.create_or_update( + resource_group_name=resource_group.name, + peering_service_name="str", + prefix_name="str", + peering_service_prefix={ + "errorMessage": "str", + "events": [ + { + "eventDescription": "str", + "eventLevel": "str", + "eventSummary": "str", + "eventTimestamp": "2020-02-20 00:00:00", + "eventType": "str", + } + ], + "id": "str", + "learnedType": "str", + "name": "str", + "peeringServicePrefixKey": "str", + "prefix": "str", + "prefixValidationState": "str", + "provisioningState": "str", + "type": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_prefixes_delete(self, resource_group): + response = self.client.prefixes.delete( + resource_group_name=resource_group.name, + peering_service_name="str", + prefix_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_prefixes_list_by_peering_service(self, resource_group): + response = self.client.prefixes.list_by_peering_service( + resource_group_name=resource_group.name, + peering_service_name="str", + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_prefixes_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_prefixes_operations_async.py new file mode 100644 index 000000000000..c34d2310fe77 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_prefixes_operations_async.py @@ -0,0 +1,91 @@ +# 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.peering.aio import PeeringManagementClient + +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 TestPeeringManagementPrefixesOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_prefixes_get(self, resource_group): + response = await self.client.prefixes.get( + resource_group_name=resource_group.name, + peering_service_name="str", + prefix_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_prefixes_create_or_update(self, resource_group): + response = await self.client.prefixes.create_or_update( + resource_group_name=resource_group.name, + peering_service_name="str", + prefix_name="str", + peering_service_prefix={ + "errorMessage": "str", + "events": [ + { + "eventDescription": "str", + "eventLevel": "str", + "eventSummary": "str", + "eventTimestamp": "2020-02-20 00:00:00", + "eventType": "str", + } + ], + "id": "str", + "learnedType": "str", + "name": "str", + "peeringServicePrefixKey": "str", + "prefix": "str", + "prefixValidationState": "str", + "provisioningState": "str", + "type": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_prefixes_delete(self, resource_group): + response = await self.client.prefixes.delete( + resource_group_name=resource_group.name, + peering_service_name="str", + prefix_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_prefixes_list_by_peering_service(self, resource_group): + response = self.client.prefixes.list_by_peering_service( + resource_group_name=resource_group.name, + peering_service_name="str", + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_received_routes_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_received_routes_operations.py new file mode 100644 index 000000000000..7bcf0154e0cb --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_received_routes_operations.py @@ -0,0 +1,31 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.peering import PeeringManagementClient + +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 TestPeeringManagementReceivedRoutesOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_received_routes_list_by_peering(self, resource_group): + response = self.client.received_routes.list_by_peering( + resource_group_name=resource_group.name, + peering_name="str", + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_received_routes_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_received_routes_operations_async.py new file mode 100644 index 000000000000..96625cd649d8 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_received_routes_operations_async.py @@ -0,0 +1,32 @@ +# 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.peering.aio import PeeringManagementClient + +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 TestPeeringManagementReceivedRoutesOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_received_routes_list_by_peering(self, resource_group): + response = self.client.received_routes.list_by_peering( + resource_group_name=resource_group.name, + peering_name="str", + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_registered_asns_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_registered_asns_operations.py new file mode 100644 index 000000000000..39969383ee5b --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_registered_asns_operations.py @@ -0,0 +1,78 @@ +# 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.peering import PeeringManagementClient + +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 TestPeeringManagementRegisteredAsnsOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_registered_asns_get(self, resource_group): + response = self.client.registered_asns.get( + resource_group_name=resource_group.name, + peering_name="str", + registered_asn_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_registered_asns_create_or_update(self, resource_group): + response = self.client.registered_asns.create_or_update( + resource_group_name=resource_group.name, + peering_name="str", + registered_asn_name="str", + registered_asn={ + "asn": 0, + "id": "str", + "name": "str", + "peeringServicePrefixKey": "str", + "provisioningState": "str", + "type": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_registered_asns_delete(self, resource_group): + response = self.client.registered_asns.delete( + resource_group_name=resource_group.name, + peering_name="str", + registered_asn_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_registered_asns_list_by_peering(self, resource_group): + response = self.client.registered_asns.list_by_peering( + resource_group_name=resource_group.name, + peering_name="str", + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_registered_asns_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_registered_asns_operations_async.py new file mode 100644 index 000000000000..418c5e466269 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_registered_asns_operations_async.py @@ -0,0 +1,79 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.peering.aio import PeeringManagementClient + +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 TestPeeringManagementRegisteredAsnsOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_registered_asns_get(self, resource_group): + response = await self.client.registered_asns.get( + resource_group_name=resource_group.name, + peering_name="str", + registered_asn_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_registered_asns_create_or_update(self, resource_group): + response = await self.client.registered_asns.create_or_update( + resource_group_name=resource_group.name, + peering_name="str", + registered_asn_name="str", + registered_asn={ + "asn": 0, + "id": "str", + "name": "str", + "peeringServicePrefixKey": "str", + "provisioningState": "str", + "type": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_registered_asns_delete(self, resource_group): + response = await self.client.registered_asns.delete( + resource_group_name=resource_group.name, + peering_name="str", + registered_asn_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_registered_asns_list_by_peering(self, resource_group): + response = self.client.registered_asns.list_by_peering( + resource_group_name=resource_group.name, + peering_name="str", + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_registered_prefixes_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_registered_prefixes_operations.py new file mode 100644 index 000000000000..21357d8ffea5 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_registered_prefixes_operations.py @@ -0,0 +1,93 @@ +# 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.peering import PeeringManagementClient + +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 TestPeeringManagementRegisteredPrefixesOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_registered_prefixes_get(self, resource_group): + response = self.client.registered_prefixes.get( + resource_group_name=resource_group.name, + peering_name="str", + registered_prefix_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_registered_prefixes_create_or_update(self, resource_group): + response = self.client.registered_prefixes.create_or_update( + resource_group_name=resource_group.name, + peering_name="str", + registered_prefix_name="str", + registered_prefix={ + "errorMessage": "str", + "id": "str", + "name": "str", + "peeringServicePrefixKey": "str", + "prefix": "str", + "prefixValidationState": "str", + "provisioningState": "str", + "type": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_registered_prefixes_delete(self, resource_group): + response = self.client.registered_prefixes.delete( + resource_group_name=resource_group.name, + peering_name="str", + registered_prefix_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_registered_prefixes_list_by_peering(self, resource_group): + response = self.client.registered_prefixes.list_by_peering( + resource_group_name=resource_group.name, + peering_name="str", + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_registered_prefixes_validate(self, resource_group): + response = self.client.registered_prefixes.validate( + resource_group_name=resource_group.name, + peering_name="str", + registered_prefix_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_registered_prefixes_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_registered_prefixes_operations_async.py new file mode 100644 index 000000000000..7a6dffa96040 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_registered_prefixes_operations_async.py @@ -0,0 +1,94 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.peering.aio import PeeringManagementClient + +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 TestPeeringManagementRegisteredPrefixesOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_registered_prefixes_get(self, resource_group): + response = await self.client.registered_prefixes.get( + resource_group_name=resource_group.name, + peering_name="str", + registered_prefix_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_registered_prefixes_create_or_update(self, resource_group): + response = await self.client.registered_prefixes.create_or_update( + resource_group_name=resource_group.name, + peering_name="str", + registered_prefix_name="str", + registered_prefix={ + "errorMessage": "str", + "id": "str", + "name": "str", + "peeringServicePrefixKey": "str", + "prefix": "str", + "prefixValidationState": "str", + "provisioningState": "str", + "type": "str", + }, + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_registered_prefixes_delete(self, resource_group): + response = await self.client.registered_prefixes.delete( + resource_group_name=resource_group.name, + peering_name="str", + registered_prefix_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_registered_prefixes_list_by_peering(self, resource_group): + response = self.client.registered_prefixes.list_by_peering( + resource_group_name=resource_group.name, + peering_name="str", + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_registered_prefixes_validate(self, resource_group): + response = await self.client.registered_prefixes.validate( + resource_group_name=resource_group.name, + peering_name="str", + registered_prefix_name="str", + api_version="2025-05-01", + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_rp_unbilled_prefixes_operations.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_rp_unbilled_prefixes_operations.py new file mode 100644 index 000000000000..964ff54cbfd9 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_rp_unbilled_prefixes_operations.py @@ -0,0 +1,31 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.peering import PeeringManagementClient + +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 TestPeeringManagementRpUnbilledPrefixesOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_rp_unbilled_prefixes_list(self, resource_group): + response = self.client.rp_unbilled_prefixes.list( + resource_group_name=resource_group.name, + peering_name="str", + api_version="2025-05-01", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_rp_unbilled_prefixes_operations_async.py b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_rp_unbilled_prefixes_operations_async.py new file mode 100644 index 000000000000..b270eb6d5c92 --- /dev/null +++ b/sdk/peering/azure-mgmt-peering/generated_tests/test_peering_management_rp_unbilled_prefixes_operations_async.py @@ -0,0 +1,32 @@ +# 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.peering.aio import PeeringManagementClient + +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 TestPeeringManagementRpUnbilledPrefixesOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(PeeringManagementClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_rp_unbilled_prefixes_list(self, resource_group): + response = self.client.rp_unbilled_prefixes.list( + resource_group_name=resource_group.name, + peering_name="str", + api_version="2025-05-01", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/peering/azure-mgmt-peering/sdk_packaging.toml b/sdk/peering/azure-mgmt-peering/sdk_packaging.toml index 6523b308ccd0..97ccd6c03608 100644 --- a/sdk/peering/azure-mgmt-peering/sdk_packaging.toml +++ b/sdk/peering/azure-mgmt-peering/sdk_packaging.toml @@ -3,6 +3,6 @@ package_name = "azure-mgmt-peering" package_nspkg = "azure-mgmt-nspkg" package_pprint_name = "Peering Management" package_doc_id = "" -is_stable = false +is_stable = true is_arm = true title = "PeeringManagementClient" diff --git a/sdk/peering/azure-mgmt-peering/setup.py b/sdk/peering/azure-mgmt-peering/setup.py index 9ddde0eb9244..b3cd38467739 100644 --- a/sdk/peering/azure-mgmt-peering/setup.py +++ b/sdk/peering/azure-mgmt-peering/setup.py @@ -1,10 +1,10 @@ #!/usr/bin/env python -#------------------------------------------------------------------------- +# ------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. -#-------------------------------------------------------------------------- +# -------------------------------------------------------------------------- import re import os.path @@ -16,63 +16,67 @@ PACKAGE_PPRINT_NAME = "Peering Management" # a-b-c => a/b/c -package_folder_path = PACKAGE_NAME.replace('-', '/') +package_folder_path = PACKAGE_NAME.replace("-", "/") # a-b-c => a.b.c -namespace_name = PACKAGE_NAME.replace('-', '.') +namespace_name = PACKAGE_NAME.replace("-", ".") # Version extraction inspired from 'requests' -with open(os.path.join(package_folder_path, 'version.py') - if os.path.exists(os.path.join(package_folder_path, 'version.py')) - else os.path.join(package_folder_path, '_version.py'), 'r') as fd: - version = re.search(r'^VERSION\s*=\s*[\'"]([^\'"]*)[\'"]', - fd.read(), re.MULTILINE).group(1) +with open( + os.path.join(package_folder_path, "version.py") + if os.path.exists(os.path.join(package_folder_path, "version.py")) + else os.path.join(package_folder_path, "_version.py"), + "r", +) as fd: + version = re.search(r'^VERSION\s*=\s*[\'"]([^\'"]*)[\'"]', fd.read(), re.MULTILINE).group(1) if not version: - raise RuntimeError('Cannot find version information') + raise RuntimeError("Cannot find version information") -with open('README.md', encoding='utf-8') as f: +with open("README.md", encoding="utf-8") as f: readme = f.read() -with open('CHANGELOG.md', encoding='utf-8') as f: +with open("CHANGELOG.md", encoding="utf-8") as f: changelog = f.read() setup( name=PACKAGE_NAME, version=version, - description='Microsoft Azure {} Client Library for Python'.format(PACKAGE_PPRINT_NAME), - long_description=readme + '\n\n' + changelog, - long_description_content_type='text/markdown', - license='MIT License', - author='Microsoft Corporation', - author_email='azpysdkhelp@microsoft.com', - url='https://github.com/Azure/azure-sdk-for-python', + description="Microsoft Azure {} Client Library for Python".format(PACKAGE_PPRINT_NAME), + long_description=readme + "\n\n" + changelog, + long_description_content_type="text/markdown", + license="MIT License", + author="Microsoft Corporation", + author_email="azpysdkhelp@microsoft.com", + url="https://github.com/Azure/azure-sdk-for-python", keywords="azure, azure sdk", # update with search keywords relevant to the azure service / product classifiers=[ - 'Development Status :: 4 - Beta', - 'Programming Language :: Python', - 'Programming Language :: Python :: 3 :: Only', - 'Programming Language :: Python :: 3', - 'Programming Language :: Python :: 3.7', - 'Programming Language :: Python :: 3.8', - 'Programming Language :: Python :: 3.9', - 'Programming Language :: Python :: 3.10', - 'License :: OSI Approved :: MIT License', + "Development Status :: 5 - Production/Stable", + "Programming Language :: Python", + "Programming Language :: Python :: 3 :: Only", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "License :: OSI Approved :: MIT License", ], zip_safe=False, - packages=find_packages(exclude=[ - 'tests', - # Exclude packages that will be covered by PEP420 or nspkg - 'azure', - 'azure.mgmt', - ]), + packages=find_packages( + exclude=[ + "tests", + # Exclude packages that will be covered by PEP420 or nspkg + "azure", + "azure.mgmt", + ] + ), include_package_data=True, package_data={ - 'pytyped': ['py.typed'], + "pytyped": ["py.typed"], }, install_requires=[ - "msrest>=0.7.1", - "azure-common~=1.1", - "azure-mgmt-core>=1.3.2,<2.0.0", - "typing-extensions>=4.3.0; python_version<'3.8.0'", + "isodate>=0.6.1", + "typing-extensions>=4.6.0", + "azure-common>=1.1", + "azure-mgmt-core>=1.5.0", ], - python_requires=">=3.7" + python_requires=">=3.9", )