diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/CHANGELOG.md b/sdk/connectedcache/azure-mgmt-connectedcache/CHANGELOG.md index 9f1c45da9f66..f4909660e6a8 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/CHANGELOG.md +++ b/sdk/connectedcache/azure-mgmt-connectedcache/CHANGELOG.md @@ -1,5 +1,31 @@ # Release History +## 1.0.0b3 (2026-07-22) + +### Features Added + + - Model `AdditionalCacheNodeProperties` added property `app_version_wsl` + - Model `AdditionalCacheNodeProperties` added property `container_os_build` + - Model `AdditionalCacheNodeProperties` added property `container_os_edition` + - Model `AdditionalCacheNodeProperties` added property `container_os_version` + - Model `AdditionalCacheNodeProperties` added property `distro_os_build_wsl` + - Model `AdditionalCacheNodeProperties` added property `distro_os_edition_wsl` + - Model `AdditionalCacheNodeProperties` added property `distro_os_version_wsl` + - Model `AdditionalCacheNodeProperties` added property `host_os_build` + - Model `AdditionalCacheNodeProperties` added property `host_os_edition` + - Model `AdditionalCacheNodeProperties` added property `host_os_version` + - Model `AdditionalCacheNodeProperties` added property `install_version_msix` + - Model `AdditionalCacheNodeProperties` added property `install_version_script` + - Enum `AutoUpdateRingType` added member `BETA` + - Enum `AutoUpdateRingType` added member `STABLE` + - Model `CacheNodeEntity` added property `bgp_network_interface` + - Model `CacheNodeEntity` added property `open_firewall_port443` + - Model `CacheNodeEntity` added property `open_firewall_port5000` + - Model `CacheNodeEntity` added property `open_firewall_port5001` + - Model `CacheNodeEntity` added property `open_firewall_port80` + - Model `CacheNodeEntity` added property `runtime_account_type` + - Model `MccCacheNodeTlsCertificate` added property `cert_type` + ## 1.0.0b2 (2025-01-13) ### Features Added diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/README.md b/sdk/connectedcache/azure-mgmt-connectedcache/README.md index f90866e50802..1b72022dba3c 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/README.md +++ b/sdk/connectedcache/azure-mgmt-connectedcache/README.md @@ -1,7 +1,7 @@ # Microsoft Azure SDK for Python This is the Microsoft Azure Connectedcache Management Client Library. -This package has been tested with Python 3.9+. +This package has been tested with Python 3.10+. For a more complete view of Azure libraries, see the [azure sdk python release](https://aka.ms/azsdk/python/all). ## _Disclaimer_ @@ -12,7 +12,7 @@ _Azure SDK Python packages support for Python 2.7 has ended 01 January 2022. For ### Prerequisites -- Python 3.9+ is required to use this package. +- Python 3.10+ is required to use this package. - [Azure subscription](https://azure.microsoft.com/free/) ### Install the package @@ -24,7 +24,7 @@ pip install azure-identity ### Authentication -By default, [Azure Active Directory](https://aka.ms/awps/aad) token authentication depends on correct configuration of the following environment variables. +By default, [Microsoft Entra](https://learn.microsoft.com/entra/fundamentals/what-is-entra) token authentication depends on correct configuration of the following environment variables. - `AZURE_CLIENT_ID` for Azure client ID. - `AZURE_TENANT_ID` for Azure tenant ID. diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/_metadata.json b/sdk/connectedcache/azure-mgmt-connectedcache/_metadata.json index 8a6a03cca4b6..65a54f8662f0 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/_metadata.json +++ b/sdk/connectedcache/azure-mgmt-connectedcache/_metadata.json @@ -1,7 +1,11 @@ { - "apiVersion": "2024-11-30-preview", - "commit": "be46becafeb29aa993898709e35759d3643b2809", + "apiVersion": "2026-06-01", + "apiVersions": { + "Microsoft.ConnectedCache": "2026-06-01" + }, + "commit": "7b08703f0340226430bd8838aad0d7ac4ab5a665", "repository_url": "https://github.com/Azure/azure-rest-api-specs", "typespec_src": "specification/connectedcache/ConnectedCache.Management", - "emitterVersion": "0.56.1" + "emitterVersion": "0.63.3", + "httpClientPythonVersion": "^0.34.2" } \ No newline at end of file diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/api.md b/sdk/connectedcache/azure-mgmt-connectedcache/api.md new file mode 100644 index 000000000000..793442ede42c --- /dev/null +++ b/sdk/connectedcache/azure-mgmt-connectedcache/api.md @@ -0,0 +1,2501 @@ +```py +namespace azure.mgmt.connectedcache + + class azure.mgmt.connectedcache.ConnectedCacheMgmtClient: implements ContextManager + enterprise_mcc_cache_nodes_operations: EnterpriseMccCacheNodesOperationsOperations + enterprise_mcc_customers: EnterpriseMccCustomersOperations + isp_cache_nodes_operations: IspCacheNodesOperationsOperations + isp_customers: IspCustomersOperations + operations: Operations + + def __init__( + self, + credential: TokenCredential, + subscription_id: str, + base_url: Optional[str] = None, + *, + api_version: str = ..., + cloud_setting: Optional[AzureClouds] = ..., + polling_interval: Optional[int] = ..., + **kwargs: Any + ) -> None: ... + + def close(self) -> None: ... + + def send_request( + self, + request: HttpRequest, + *, + stream: bool = False, + **kwargs: Any + ) -> HttpResponse: ... + + +namespace azure.mgmt.connectedcache.aio + + class azure.mgmt.connectedcache.aio.ConnectedCacheMgmtClient: implements AsyncContextManager + enterprise_mcc_cache_nodes_operations: EnterpriseMccCacheNodesOperationsOperations + enterprise_mcc_customers: EnterpriseMccCustomersOperations + isp_cache_nodes_operations: IspCacheNodesOperationsOperations + isp_customers: IspCustomersOperations + operations: Operations + + def __init__( + self, + credential: AsyncTokenCredential, + subscription_id: str, + base_url: Optional[str] = None, + *, + api_version: str = ..., + cloud_setting: Optional[AzureClouds] = ..., + polling_interval: Optional[int] = ..., + **kwargs: Any + ) -> None: ... + + async def close(self) -> None: ... + + def send_request( + self, + request: HttpRequest, + *, + stream: bool = False, + **kwargs: Any + ) -> Awaitable[AsyncHttpResponse]: ... + + +namespace azure.mgmt.connectedcache.aio.operations + + class azure.mgmt.connectedcache.aio.operations.EnterpriseMccCacheNodesOperationsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + resource: EnterpriseMccCacheNodeResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[EnterpriseMccCacheNodeResource]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + resource: EnterpriseMccCacheNodeResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[EnterpriseMccCacheNodeResource]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[EnterpriseMccCacheNodeResource]: ... + + @distributed_trace_async + async def begin_delete( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> EnterpriseMccCacheNodeResource: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2024-11-30-preview', params_added_on={'2024-11-30-preview': ['api_version', 'subscription_id', 'resource_group_name', 'customer_resource_name', 'cache_node_resource_name', 'accept']}, api_versions_list=['2024-11-30-preview', '2026-06-01']) + async def get_cache_node_auto_update_history( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeAutoUpdateHistory: ... + + @distributed_trace_async + async def get_cache_node_install_details( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeInstallDetails: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2024-11-30-preview', params_added_on={'2024-11-30-preview': ['api_version', 'subscription_id', 'resource_group_name', 'customer_resource_name', 'cache_node_resource_name', 'accept']}, api_versions_list=['2024-11-30-preview', '2026-06-01']) + async def get_cache_node_mcc_issue_details_history( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeIssueHistory: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2024-11-30-preview', params_added_on={'2024-11-30-preview': ['api_version', 'subscription_id', 'resource_group_name', 'customer_resource_name', 'cache_node_resource_name', 'accept']}, api_versions_list=['2024-11-30-preview', '2026-06-01']) + async def get_cache_node_tls_certificate_history( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeTlsCertificateHistory: ... + + @distributed_trace + def list_by_enterprise_mcc_customer_resource( + self, + resource_group_name: str, + customer_resource_name: str, + **kwargs: Any + ) -> AsyncItemPaged[EnterpriseMccCacheNodeResource]: ... + + @overload + async def update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> EnterpriseMccCacheNodeResource: ... + + @overload + async def update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> EnterpriseMccCacheNodeResource: ... + + @overload + async def update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> EnterpriseMccCacheNodeResource: ... + + + class azure.mgmt.connectedcache.aio.operations.EnterpriseMccCustomersOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + resource: EnterpriseMccCustomerResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[EnterpriseMccCustomerResource]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + resource: EnterpriseMccCustomerResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[EnterpriseMccCustomerResource]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[EnterpriseMccCustomerResource]: ... + + @distributed_trace_async + async def begin_delete( + self, + resource_group_name: str, + customer_resource_name: str, + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + customer_resource_name: str, + **kwargs: Any + ) -> EnterpriseMccCustomerResource: ... + + @distributed_trace + def list_by_resource_group( + self, + resource_group_name: str, + **kwargs: Any + ) -> AsyncItemPaged[EnterpriseMccCustomerResource]: ... + + @distributed_trace + def list_by_subscription(self, **kwargs: Any) -> AsyncItemPaged[EnterpriseMccCustomerResource]: ... + + @overload + async def update( + self, + resource_group_name: str, + customer_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> EnterpriseMccCustomerResource: ... + + @overload + async def update( + self, + resource_group_name: str, + customer_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> EnterpriseMccCustomerResource: ... + + @overload + async def update( + self, + resource_group_name: str, + customer_resource_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> EnterpriseMccCustomerResource: ... + + + class azure.mgmt.connectedcache.aio.operations.IspCacheNodesOperationsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + resource: IspCacheNodeResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[IspCacheNodeResource]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + resource: IspCacheNodeResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[IspCacheNodeResource]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[IspCacheNodeResource]: ... + + @distributed_trace_async + async def begin_delete( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> IspCacheNodeResource: ... + + @distributed_trace_async + async def get_bgp_cidrs( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeBgpCidrDetails: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2024-11-30-preview', params_added_on={'2024-11-30-preview': ['api_version', 'subscription_id', 'resource_group_name', 'customer_resource_name', 'cache_node_resource_name', 'accept']}, api_versions_list=['2024-11-30-preview', '2026-06-01']) + async def get_cache_node_auto_update_history( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeAutoUpdateHistory: ... + + @distributed_trace_async + async def get_cache_node_install_details( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeInstallDetails: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2024-11-30-preview', params_added_on={'2024-11-30-preview': ['api_version', 'subscription_id', 'resource_group_name', 'customer_resource_name', 'cache_node_resource_name', 'accept']}, api_versions_list=['2024-11-30-preview', '2026-06-01']) + async def get_cache_node_mcc_issue_details_history( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeIssueHistory: ... + + @distributed_trace + def list_by_isp_customer_resource( + self, + resource_group_name: str, + customer_resource_name: str, + **kwargs: Any + ) -> AsyncItemPaged[IspCacheNodeResource]: ... + + @overload + async def update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> IspCacheNodeResource: ... + + @overload + async def update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> IspCacheNodeResource: ... + + @overload + async def update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> IspCacheNodeResource: ... + + + class azure.mgmt.connectedcache.aio.operations.IspCustomersOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + resource: IspCustomerResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[IspCustomerResource]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + resource: IspCustomerResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[IspCustomerResource]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[IspCustomerResource]: ... + + @distributed_trace_async + async def begin_delete( + self, + resource_group_name: str, + customer_resource_name: str, + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + customer_resource_name: str, + **kwargs: Any + ) -> IspCustomerResource: ... + + @distributed_trace + def list_by_resource_group( + self, + resource_group_name: str, + **kwargs: Any + ) -> AsyncItemPaged[IspCustomerResource]: ... + + @distributed_trace + def list_by_subscription(self, **kwargs: Any) -> AsyncItemPaged[IspCustomerResource]: ... + + @overload + async def update( + self, + resource_group_name: str, + customer_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> IspCustomerResource: ... + + @overload + async def update( + self, + resource_group_name: str, + customer_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> IspCustomerResource: ... + + @overload + async def update( + self, + resource_group_name: str, + customer_resource_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> IspCustomerResource: ... + + + class azure.mgmt.connectedcache.aio.operations.Operations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list(self, **kwargs: Any) -> AsyncItemPaged[Operation]: ... + + +namespace azure.mgmt.connectedcache.models + + class azure.mgmt.connectedcache.models.ActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INTERNAL = "Internal" + + + class azure.mgmt.connectedcache.models.AdditionalCacheNodeProperties(_Model): + aggregated_status_code: Optional[int] + aggregated_status_details: Optional[str] + aggregated_status_text: Optional[str] + app_version_wsl: Optional[str] + auto_update_applied_version: Optional[str] + auto_update_last_applied_date_time: Optional[datetime] + auto_update_last_applied_details: Optional[str] + auto_update_last_applied_state: Optional[str] + auto_update_last_triggered_date_time: Optional[datetime] + auto_update_next_available_date_time: Optional[datetime] + auto_update_next_available_version: Optional[str] + auto_update_version: Optional[str] + bgp_configuration: Optional[BgpConfiguration] + cache_node_properties_details_issues_list: Optional[list[str]] + cache_node_state: Optional[int] + cache_node_state_detailed_text: Optional[str] + cache_node_state_short_text: Optional[str] + container_os_build: Optional[str] + container_os_edition: Optional[str] + container_os_version: Optional[str] + creation_method: Optional[int] + current_tls_certificate: Optional[MccCacheNodeTlsCertificate] + distro_os_build_wsl: Optional[str] + distro_os_edition_wsl: Optional[str] + distro_os_version_wsl: Optional[str] + drive_configuration: Optional[list[CacheNodeDriveConfiguration]] + host_os_build: Optional[str] + host_os_edition: Optional[str] + host_os_version: Optional[str] + install_version_msix: Optional[str] + install_version_script: Optional[str] + is_provisioned: Optional[bool] + is_proxy_required: Optional[Union[str, ProxyRequired]] + issues_count: Optional[int] + issues_list: Optional[list[str]] + last_auto_update_info: Optional[MccCacheNodeAutoUpdateInfo] + optional_property1: Optional[str] + optional_property2: Optional[str] + optional_property3: Optional[str] + optional_property4: Optional[str] + optional_property5: Optional[str] + os_type: Optional[Union[str, OsType]] + product_version: Optional[str] + proxy_url_configuration: Optional[ProxyUrlConfiguration] + tls_status: Optional[str] + update_info_details: Optional[str] + update_requested_date_time: Optional[datetime] + + @overload + def __init__( + self, + *, + auto_update_version: Optional[str] = ..., + bgp_configuration: Optional[BgpConfiguration] = ..., + cache_node_properties_details_issues_list: Optional[list[str]] = ..., + creation_method: Optional[int] = ..., + drive_configuration: Optional[list[CacheNodeDriveConfiguration]] = ..., + is_proxy_required: Optional[Union[str, ProxyRequired]] = ..., + optional_property1: Optional[str] = ..., + optional_property2: Optional[str] = ..., + optional_property3: Optional[str] = ..., + optional_property4: Optional[str] = ..., + optional_property5: Optional[str] = ..., + os_type: Optional[Union[str, OsType]] = ..., + proxy_url_configuration: Optional[ProxyUrlConfiguration] = ..., + update_info_details: Optional[str] = ..., + update_requested_date_time: Optional[datetime] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.AdditionalCustomerProperties(_Model): + customer_asn: Optional[str] + customer_asn_estimated_egress_peek_gbps: Optional[float] + customer_email: Optional[str] + customer_entitlement_expiration: Optional[datetime] + customer_entitlement_sku_guid: Optional[str] + customer_entitlement_sku_id: Optional[str] + customer_entitlement_sku_name: Optional[str] + customer_org_name: Optional[str] + customer_properties_overview_average_egress_mbps: Optional[float] + customer_properties_overview_average_miss_mbps: Optional[float] + customer_properties_overview_cache_efficiency: Optional[float] + customer_properties_overview_cache_nodes_healthy_count: Optional[int] + customer_properties_overview_cache_nodes_unhealthy_count: Optional[int] + customer_properties_overview_egress_mbps_max: Optional[float] + customer_properties_overview_egress_mbps_max_date_time: Optional[datetime] + customer_properties_overview_miss_mbps_max: Optional[float] + customer_properties_overview_miss_mbps_max_date_time: Optional[datetime] + customer_transit_asn: Optional[str] + customer_transit_state: Optional[Union[str, CustomerTransitState]] + optional_property1: Optional[str] + optional_property2: Optional[str] + optional_property3: Optional[str] + optional_property4: Optional[str] + optional_property5: Optional[str] + peering_db_last_update_date: Optional[datetime] + signup_phase_status_code: Optional[int] + signup_phase_status_text: Optional[str] + signup_status: Optional[bool] + signup_status_code: Optional[int] + signup_status_text: Optional[str] + + @overload + def __init__( + self, + *, + customer_asn: Optional[str] = ..., + customer_email: Optional[str] = ..., + customer_entitlement_expiration: Optional[datetime] = ..., + customer_entitlement_sku_guid: Optional[str] = ..., + customer_entitlement_sku_id: Optional[str] = ..., + customer_entitlement_sku_name: Optional[str] = ..., + customer_transit_asn: Optional[str] = ..., + customer_transit_state: Optional[Union[str, CustomerTransitState]] = ..., + optional_property1: Optional[str] = ..., + optional_property2: Optional[str] = ..., + optional_property3: Optional[str] = ..., + optional_property4: Optional[str] = ..., + optional_property5: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.AutoUpdateRingType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + BETA = "Beta" + FAST = "Fast" + PREVIEW = "Preview" + SLOW = "Slow" + STABLE = "Stable" + + + class azure.mgmt.connectedcache.models.BgpCidrsConfiguration(_Model): + bgp_cidrs: Optional[list[str]] + + + class azure.mgmt.connectedcache.models.BgpConfiguration(_Model): + asn_to_ip_address_mapping: Optional[str] + + @overload + def __init__( + self, + *, + asn_to_ip_address_mapping: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.BgpReviewStateEnum(str, Enum, metaclass=CaseInsensitiveEnumMeta): + APPROVED = "Approved" + ATTENTION_REQUIRED = "AttentionRequired" + IN_REVIEW = "InReview" + NOT_CONFIGURED = "NotConfigured" + + + class azure.mgmt.connectedcache.models.CacheNodeDriveConfiguration(_Model): + cache_number: Optional[int] + nginx_mapping: Optional[str] + physical_path: Optional[str] + size_in_gb: Optional[int] + + @overload + def __init__( + self, + *, + cache_number: Optional[int] = ..., + nginx_mapping: Optional[str] = ..., + physical_path: Optional[str] = ..., + size_in_gb: Optional[int] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.CacheNodeEntity(_Model): + address_space: Optional[int] + auto_update_requested_day: Optional[int] + auto_update_requested_time: Optional[str] + auto_update_requested_week: Optional[int] + auto_update_ring_type: Optional[Union[str, AutoUpdateRingType]] + bgp_address_space: Optional[int] + bgp_cidr_blocks_count: Optional[int] + bgp_cidr_csv_last_update_time: Optional[datetime] + bgp_file_bytes_truncated: Optional[int] + bgp_last_reported_time: Optional[datetime] + bgp_network_interface: Optional[str] + bgp_number_of_records: Optional[int] + bgp_number_of_times_updated: Optional[int] + bgp_review_feedback: Optional[str] + bgp_review_state: Optional[Union[str, BgpReviewStateEnum]] + bgp_review_state_text: Optional[str] + cache_node_id: Optional[str] + cache_node_name: Optional[str] + category: Optional[str] + cidr_csv: Optional[list[str]] + cidr_csv_last_update_time: Optional[datetime] + cidr_selection_type: Optional[int] + client_tenant_id: Optional[str] + configuration_state: Optional[Union[str, ConfigurationState]] + configuration_state_text: Optional[str] + container_configurations: Optional[str] + container_resync_trigger: Optional[int] + create_async_operation_id: Optional[str] + customer_asn: Optional[int] + customer_id: Optional[str] + customer_index: Optional[str] + customer_name: Optional[str] + delete_async_operation_id: Optional[str] + fully_qualified_domain_name: Optional[str] + fully_qualified_resource_id: Optional[str] + image_uri: Optional[str] + ip_address: Optional[str] + is_enabled: Optional[bool] + is_enterprise_managed: Optional[bool] + is_frozen: Optional[bool] + last_sync_with_azure_timestamp: Optional[datetime] + last_updated_timestamp: Optional[datetime] + max_allowable_egress_in_mbps: Optional[int] + max_allowable_probability: Optional[float] + open_firewall_port443: Optional[bool] + open_firewall_port5000: Optional[bool] + open_firewall_port5001: Optional[bool] + open_firewall_port80: Optional[bool] + release_version: Optional[int] + review_feedback: Optional[str] + review_state: Optional[int] + review_state_text: Optional[str] + runtime_account_type: Optional[str] + should_migrate: Optional[bool] + synch_with_azure_attempts_count: Optional[int] + worker_connections: Optional[int] + worker_connections_last_updated_date_time: Optional[datetime] + x_cid: Optional[str] + + @overload + def __init__( + self, + *, + auto_update_requested_day: Optional[int] = ..., + auto_update_requested_time: Optional[str] = ..., + auto_update_requested_week: Optional[int] = ..., + auto_update_ring_type: Optional[Union[str, AutoUpdateRingType]] = ..., + bgp_network_interface: Optional[str] = ..., + cache_node_id: Optional[str] = ..., + cache_node_name: Optional[str] = ..., + cidr_csv: Optional[list[str]] = ..., + cidr_selection_type: Optional[int] = ..., + customer_asn: Optional[int] = ..., + customer_index: Optional[str] = ..., + customer_name: Optional[str] = ..., + fully_qualified_domain_name: Optional[str] = ..., + fully_qualified_resource_id: Optional[str] = ..., + ip_address: Optional[str] = ..., + is_enabled: Optional[bool] = ..., + is_enterprise_managed: Optional[bool] = ..., + max_allowable_egress_in_mbps: Optional[int] = ..., + open_firewall_port443: Optional[bool] = ..., + open_firewall_port5000: Optional[bool] = ..., + open_firewall_port5001: Optional[bool] = ..., + open_firewall_port80: Optional[bool] = ..., + runtime_account_type: Optional[str] = ..., + should_migrate: Optional[bool] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.CacheNodeInstallProperties(_Model): + cache_node_id: Optional[str] + customer_id: Optional[str] + drive_configuration: Optional[list[CacheNodeDriveConfiguration]] + primary_account_key: Optional[str] + proxy_url_configuration: Optional[ProxyUrlConfiguration] + registration_key: Optional[str] + secondary_account_key: Optional[str] + tls_certificate_provisioning_key: Optional[str] + + @overload + def __init__( + self, + *, + cache_node_id: Optional[str] = ..., + customer_id: Optional[str] = ..., + drive_configuration: Optional[list[CacheNodeDriveConfiguration]] = ..., + proxy_url_configuration: Optional[ProxyUrlConfiguration] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.CacheNodeProperty(_Model): + additional_cache_node_properties: Optional[AdditionalCacheNodeProperties] + cache_node: Optional[CacheNodeEntity] + error: Optional[ErrorDetail] + provisioning_state: Optional[Union[str, ProvisioningState]] + status: Optional[str] + status_code: Optional[str] + status_details: Optional[str] + status_text: Optional[str] + + @overload + def __init__( + self, + *, + additional_cache_node_properties: Optional[AdditionalCacheNodeProperties] = ..., + cache_node: Optional[CacheNodeEntity] = ..., + error: Optional[ErrorDetail] = ..., + status_code: Optional[str] = ..., + status_details: Optional[str] = ..., + status_text: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.ConfigurationState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CONFIGURED = "Configured" + NOT_CONFIGURED_IP = "NotConfigured_Ip" + + + class azure.mgmt.connectedcache.models.ConnectedCachePatchResource(_Model): + tags: Optional[dict[str, str]] + + @overload + def __init__( + self, + *, + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.CreatedByType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + APPLICATION = "Application" + KEY = "Key" + MANAGED_IDENTITY = "ManagedIdentity" + USER = "User" + + + class azure.mgmt.connectedcache.models.CustomerEntity(_Model): + client_tenant_id: Optional[str] + contact_email: Optional[str] + contact_name: Optional[str] + contact_phone: Optional[str] + create_async_operation_id: Optional[str] + customer_id: Optional[str] + customer_name: Optional[str] + delete_async_operation_id: Optional[str] + fully_qualified_resource_id: Optional[str] + is_enterprise_managed: Optional[bool] + is_entitled: Optional[bool] + last_sync_with_azure_timestamp: Optional[datetime] + release_version: Optional[int] + resend_signup_code: Optional[bool] + should_migrate: Optional[bool] + synch_with_azure_attempts_count: Optional[int] + verify_signup_code: Optional[bool] + verify_signup_phrase: Optional[str] + + @overload + def __init__( + self, + *, + client_tenant_id: Optional[str] = ..., + contact_email: Optional[str] = ..., + contact_name: Optional[str] = ..., + contact_phone: Optional[str] = ..., + customer_name: Optional[str] = ..., + fully_qualified_resource_id: Optional[str] = ..., + is_enterprise_managed: Optional[bool] = ..., + is_entitled: Optional[bool] = ..., + release_version: Optional[int] = ..., + resend_signup_code: Optional[bool] = ..., + should_migrate: Optional[bool] = ..., + verify_signup_code: Optional[bool] = ..., + verify_signup_phrase: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.CustomerProperty(_Model): + additional_customer_properties: Optional[AdditionalCustomerProperties] + customer: Optional[CustomerEntity] + error: Optional[ErrorDetail] + provisioning_state: Optional[Union[str, ProvisioningState]] + status: Optional[str] + status_code: Optional[str] + status_details: Optional[str] + status_text: Optional[str] + + @overload + def __init__( + self, + *, + additional_customer_properties: Optional[AdditionalCustomerProperties] = ..., + customer: Optional[CustomerEntity] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.CustomerTransitState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + COMBINED_TRANSIT = "CombinedTransit" + NO_TRANSIT = "NoTransit" + TRANSIT_ONLY = "TransitOnly" + + + class azure.mgmt.connectedcache.models.EnterpriseMccCacheNodeResource(TrackedResource): + id: str + location: str + name: str + properties: Optional[CacheNodeProperty] + system_data: SystemData + tags: dict[str, str] + type: str + + @overload + def __init__( + self, + *, + location: str, + properties: Optional[CacheNodeProperty] = ..., + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.EnterpriseMccCustomerResource(TrackedResource): + id: str + location: str + name: str + properties: Optional[CustomerProperty] + system_data: SystemData + tags: dict[str, str] + type: str + + @overload + def __init__( + self, + *, + location: str, + properties: Optional[CustomerProperty] = ..., + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.ErrorAdditionalInfo(_Model): + info: Optional[Any] + type: Optional[str] + + + class azure.mgmt.connectedcache.models.ErrorDetail(_Model): + additional_info: Optional[list[ErrorAdditionalInfo]] + code: Optional[str] + details: Optional[list[ErrorDetail]] + message: Optional[str] + target: Optional[str] + + + class azure.mgmt.connectedcache.models.ErrorResponse(_Model): + error: Optional[ErrorDetail] + + @overload + def __init__( + self, + *, + error: Optional[ErrorDetail] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.IspCacheNodeResource(TrackedResource): + id: str + location: str + name: str + properties: Optional[CacheNodeProperty] + system_data: SystemData + tags: dict[str, str] + type: str + + @overload + def __init__( + self, + *, + location: str, + properties: Optional[CacheNodeProperty] = ..., + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.IspCustomerResource(TrackedResource): + id: str + location: str + name: str + properties: Optional[CustomerProperty] + system_data: SystemData + tags: dict[str, str] + type: str + + @overload + def __init__( + self, + *, + location: str, + properties: Optional[CustomerProperty] = ..., + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.MccCacheNodeAutoUpdateHistory(TrackedResource): + id: str + location: str + name: str + properties: Optional[MccCacheNodeAutoUpdateHistoryProperties] + system_data: SystemData + tags: dict[str, str] + type: str + + @overload + def __init__( + self, + *, + location: str, + properties: Optional[MccCacheNodeAutoUpdateHistoryProperties] = ..., + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.MccCacheNodeAutoUpdateHistoryProperties(_Model): + auto_update_history: Optional[list[MccCacheNodeAutoUpdateInfo]] + cache_node_id: Optional[str] + customer_id: Optional[str] + + @overload + def __init__( + self, + *, + auto_update_history: Optional[list[MccCacheNodeAutoUpdateInfo]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.MccCacheNodeAutoUpdateInfo(_Model): + auto_update_last_applied_status: Optional[int] + auto_update_last_applied_status_detailed_text: Optional[str] + auto_update_last_applied_status_text: Optional[str] + auto_update_ring_type: Optional[int] + created_date_time_utc: Optional[datetime] + image_uri_before_update: Optional[str] + image_uri_targeted: Optional[str] + image_uri_terminal: Optional[str] + moved_to_terminal_state_date_time: Optional[datetime] + plan_change_log_text: Optional[str] + plan_id: Optional[int] + rule_requested_day: Optional[int] + rule_requested_hour: Optional[str] + rule_requested_minute: Optional[str] + rule_requested_week: Optional[int] + time_to_go_live_date_time: Optional[str] + updated_registry_date_time_utc: Optional[datetime] + + + class azure.mgmt.connectedcache.models.MccCacheNodeBgpCidrDetails(TrackedResource): + id: str + location: str + name: str + properties: Optional[BgpCidrsConfiguration] + system_data: SystemData + tags: dict[str, str] + type: str + + @overload + def __init__( + self, + *, + location: str, + properties: Optional[BgpCidrsConfiguration] = ..., + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.MccCacheNodeInstallDetails(TrackedResource): + id: str + location: str + name: str + properties: Optional[CacheNodeInstallProperties] + system_data: SystemData + tags: dict[str, str] + type: str + + @overload + def __init__( + self, + *, + location: str, + properties: Optional[CacheNodeInstallProperties] = ..., + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.MccCacheNodeIssueHistory(TrackedResource): + id: str + location: str + name: str + properties: Optional[MccCacheNodeIssueHistoryProperties] + system_data: SystemData + tags: dict[str, str] + type: str + + @overload + def __init__( + self, + *, + location: str, + properties: Optional[MccCacheNodeIssueHistoryProperties] = ..., + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.MccCacheNodeIssueHistoryProperties(_Model): + cache_node_id: Optional[str] + customer_id: Optional[str] + mcc_issue_history: Optional[list[MccIssue]] + + @overload + def __init__( + self, + *, + mcc_issue_history: Optional[list[MccIssue]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.MccCacheNodeTlsCertificate(_Model): + action_required: Optional[str] + cert_type: Optional[str] + certificate_file_name: Optional[str] + expiry_date: Optional[datetime] + not_before_date: Optional[datetime] + subject: Optional[str] + subject_alt_name: Optional[str] + thumbprint: Optional[str] + + + class azure.mgmt.connectedcache.models.MccCacheNodeTlsCertificateHistory(TrackedResource): + id: str + location: str + name: str + properties: Optional[MccCacheNodeTlsCertificateProperties] + system_data: SystemData + tags: dict[str, str] + type: str + + @overload + def __init__( + self, + *, + location: str, + properties: Optional[MccCacheNodeTlsCertificateProperties] = ..., + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.MccCacheNodeTlsCertificateProperties(_Model): + cache_node_id: Optional[str] + customer_id: Optional[str] + tls_certificate_history: Optional[list[MccCacheNodeTlsCertificate]] + + @overload + def __init__( + self, + *, + tls_certificate_history: Optional[list[MccCacheNodeTlsCertificate]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.MccIssue(_Model): + detail_string: Optional[str] + help_link: Optional[str] + issue_end_date: Optional[datetime] + issue_start_date: Optional[datetime] + mcc_issue_type: Optional[str] + toast_string: Optional[str] + + + class azure.mgmt.connectedcache.models.Operation(_Model): + action_type: Optional[Union[str, ActionType]] + display: Optional[OperationDisplay] + is_data_action: Optional[bool] + name: Optional[str] + origin: Optional[Union[str, Origin]] + + @overload + def __init__( + self, + *, + display: Optional[OperationDisplay] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.OperationDisplay(_Model): + description: Optional[str] + operation: Optional[str] + provider: Optional[str] + resource: Optional[str] + + + class azure.mgmt.connectedcache.models.Origin(str, Enum, metaclass=CaseInsensitiveEnumMeta): + SYSTEM = "system" + USER = "user" + USER_SYSTEM = "user,system" + + + class azure.mgmt.connectedcache.models.OsType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + EFLOW = "Eflow" + LINUX = "Linux" + WINDOWS = "Windows" + + + class azure.mgmt.connectedcache.models.ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ACCEPTED = "Accepted" + CANCELED = "Canceled" + DELETING = "Deleting" + FAILED = "Failed" + SUCCEEDED = "Succeeded" + UNKNOWN = "Unknown" + UPGRADING = "Upgrading" + + + class azure.mgmt.connectedcache.models.ProxyRequired(str, Enum, metaclass=CaseInsensitiveEnumMeta): + NONE = "None" + REQUIRED = "Required" + + + class azure.mgmt.connectedcache.models.ProxyUrlConfiguration(_Model): + proxy_url: Optional[str] + + @overload + def __init__( + self, + *, + proxy_url: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.Resource(_Model): + id: Optional[str] + name: Optional[str] + system_data: Optional[SystemData] + type: Optional[str] + + + class azure.mgmt.connectedcache.models.SystemData(_Model): + created_at: Optional[datetime] + created_by: Optional[str] + created_by_type: Optional[Union[str, CreatedByType]] + last_modified_at: Optional[datetime] + last_modified_by: Optional[str] + last_modified_by_type: Optional[Union[str, CreatedByType]] + + @overload + def __init__( + self, + *, + created_at: Optional[datetime] = ..., + created_by: Optional[str] = ..., + created_by_type: Optional[Union[str, CreatedByType]] = ..., + last_modified_at: Optional[datetime] = ..., + last_modified_by: Optional[str] = ..., + last_modified_by_type: Optional[Union[str, CreatedByType]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.connectedcache.models.TrackedResource(Resource): + id: str + location: str + name: str + system_data: SystemData + tags: Optional[dict[str, str]] + type: str + + @overload + def __init__( + self, + *, + location: str, + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + +namespace azure.mgmt.connectedcache.operations + + class azure.mgmt.connectedcache.operations.EnterpriseMccCacheNodesOperationsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + resource: EnterpriseMccCacheNodeResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[EnterpriseMccCacheNodeResource]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + resource: EnterpriseMccCacheNodeResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[EnterpriseMccCacheNodeResource]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[EnterpriseMccCacheNodeResource]: ... + + @distributed_trace + def begin_delete( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> LROPoller[None]: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> EnterpriseMccCacheNodeResource: ... + + @distributed_trace + @api_version_validation(method_added_on='2024-11-30-preview', params_added_on={'2024-11-30-preview': ['api_version', 'subscription_id', 'resource_group_name', 'customer_resource_name', 'cache_node_resource_name', 'accept']}, api_versions_list=['2024-11-30-preview', '2026-06-01']) + def get_cache_node_auto_update_history( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeAutoUpdateHistory: ... + + @distributed_trace + def get_cache_node_install_details( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeInstallDetails: ... + + @distributed_trace + @api_version_validation(method_added_on='2024-11-30-preview', params_added_on={'2024-11-30-preview': ['api_version', 'subscription_id', 'resource_group_name', 'customer_resource_name', 'cache_node_resource_name', 'accept']}, api_versions_list=['2024-11-30-preview', '2026-06-01']) + def get_cache_node_mcc_issue_details_history( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeIssueHistory: ... + + @distributed_trace + @api_version_validation(method_added_on='2024-11-30-preview', params_added_on={'2024-11-30-preview': ['api_version', 'subscription_id', 'resource_group_name', 'customer_resource_name', 'cache_node_resource_name', 'accept']}, api_versions_list=['2024-11-30-preview', '2026-06-01']) + def get_cache_node_tls_certificate_history( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeTlsCertificateHistory: ... + + @distributed_trace + def list_by_enterprise_mcc_customer_resource( + self, + resource_group_name: str, + customer_resource_name: str, + **kwargs: Any + ) -> ItemPaged[EnterpriseMccCacheNodeResource]: ... + + @overload + def update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> EnterpriseMccCacheNodeResource: ... + + @overload + def update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> EnterpriseMccCacheNodeResource: ... + + @overload + def update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> EnterpriseMccCacheNodeResource: ... + + + class azure.mgmt.connectedcache.operations.EnterpriseMccCustomersOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + resource: EnterpriseMccCustomerResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[EnterpriseMccCustomerResource]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + resource: EnterpriseMccCustomerResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[EnterpriseMccCustomerResource]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[EnterpriseMccCustomerResource]: ... + + @distributed_trace + def begin_delete( + self, + resource_group_name: str, + customer_resource_name: str, + **kwargs: Any + ) -> LROPoller[None]: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + customer_resource_name: str, + **kwargs: Any + ) -> EnterpriseMccCustomerResource: ... + + @distributed_trace + def list_by_resource_group( + self, + resource_group_name: str, + **kwargs: Any + ) -> ItemPaged[EnterpriseMccCustomerResource]: ... + + @distributed_trace + def list_by_subscription(self, **kwargs: Any) -> ItemPaged[EnterpriseMccCustomerResource]: ... + + @overload + def update( + self, + resource_group_name: str, + customer_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> EnterpriseMccCustomerResource: ... + + @overload + def update( + self, + resource_group_name: str, + customer_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> EnterpriseMccCustomerResource: ... + + @overload + def update( + self, + resource_group_name: str, + customer_resource_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> EnterpriseMccCustomerResource: ... + + + class azure.mgmt.connectedcache.operations.IspCacheNodesOperationsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + resource: IspCacheNodeResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[IspCacheNodeResource]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + resource: IspCacheNodeResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[IspCacheNodeResource]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[IspCacheNodeResource]: ... + + @distributed_trace + def begin_delete( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> LROPoller[None]: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> IspCacheNodeResource: ... + + @distributed_trace + def get_bgp_cidrs( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeBgpCidrDetails: ... + + @distributed_trace + @api_version_validation(method_added_on='2024-11-30-preview', params_added_on={'2024-11-30-preview': ['api_version', 'subscription_id', 'resource_group_name', 'customer_resource_name', 'cache_node_resource_name', 'accept']}, api_versions_list=['2024-11-30-preview', '2026-06-01']) + def get_cache_node_auto_update_history( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeAutoUpdateHistory: ... + + @distributed_trace + def get_cache_node_install_details( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeInstallDetails: ... + + @distributed_trace + @api_version_validation(method_added_on='2024-11-30-preview', params_added_on={'2024-11-30-preview': ['api_version', 'subscription_id', 'resource_group_name', 'customer_resource_name', 'cache_node_resource_name', 'accept']}, api_versions_list=['2024-11-30-preview', '2026-06-01']) + def get_cache_node_mcc_issue_details_history( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + **kwargs: Any + ) -> MccCacheNodeIssueHistory: ... + + @distributed_trace + def list_by_isp_customer_resource( + self, + resource_group_name: str, + customer_resource_name: str, + **kwargs: Any + ) -> ItemPaged[IspCacheNodeResource]: ... + + @overload + def update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> IspCacheNodeResource: ... + + @overload + def update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> IspCacheNodeResource: ... + + @overload + def update( + self, + resource_group_name: str, + customer_resource_name: str, + cache_node_resource_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> IspCacheNodeResource: ... + + + class azure.mgmt.connectedcache.operations.IspCustomersOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + resource: IspCustomerResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[IspCustomerResource]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + resource: IspCustomerResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[IspCustomerResource]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + customer_resource_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[IspCustomerResource]: ... + + @distributed_trace + def begin_delete( + self, + resource_group_name: str, + customer_resource_name: str, + **kwargs: Any + ) -> LROPoller[None]: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + customer_resource_name: str, + **kwargs: Any + ) -> IspCustomerResource: ... + + @distributed_trace + def list_by_resource_group( + self, + resource_group_name: str, + **kwargs: Any + ) -> ItemPaged[IspCustomerResource]: ... + + @distributed_trace + def list_by_subscription(self, **kwargs: Any) -> ItemPaged[IspCustomerResource]: ... + + @overload + def update( + self, + resource_group_name: str, + customer_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> IspCustomerResource: ... + + @overload + def update( + self, + resource_group_name: str, + customer_resource_name: str, + properties: ConnectedCachePatchResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> IspCustomerResource: ... + + @overload + def update( + self, + resource_group_name: str, + customer_resource_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> IspCustomerResource: ... + + + class azure.mgmt.connectedcache.operations.Operations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list(self, **kwargs: Any) -> ItemPaged[Operation]: ... + + +namespace azure.mgmt.connectedcache.types + + class azure.mgmt.connectedcache.types.AdditionalCacheNodeProperties(TypedDict, total=False): + key "aggregatedStatusCode": int + key "aggregatedStatusDetails": str + key "aggregatedStatusText": str + key "appVersionWsl": str + key "autoUpdateAppliedVersion": str + key "autoUpdateLastAppliedDateTime": str + key "autoUpdateLastAppliedDetails": str + key "autoUpdateLastAppliedState": str + key "autoUpdateLastTriggeredDateTime": str + key "autoUpdateNextAvailableDateTime": str + key "autoUpdateNextAvailableVersion": str + key "autoUpdateVersion": str + key "bgpConfiguration": ForwardRef('BgpConfiguration', module='types') + key "cacheNodeState": int + key "cacheNodeStateDetailedText": str + key "cacheNodeStateShortText": str + key "containerOsBuild": str + key "containerOsEdition": str + key "containerOsVersion": str + key "creationMethod": int + key "currentTlsCertificate": ForwardRef('MccCacheNodeTlsCertificate', module='types') + key "distroOsBuildWsl": str + key "distroOsEditionWsl": str + key "distroOsVersionWsl": str + key "hostOsBuild": str + key "hostOsEdition": str + key "hostOsVersion": str + key "installVersionMsix": str + key "installVersionScript": str + key "isProvisioned": bool + key "isProxyRequired": Union[str, ProxyRequired] + key "issuesCount": int + key "lastAutoUpdateInfo": ForwardRef('MccCacheNodeAutoUpdateInfo', module='types') + key "optionalProperty1": str + key "optionalProperty2": str + key "optionalProperty3": str + key "optionalProperty4": str + key "optionalProperty5": str + key "osType": Union[str, OsType] + key "productVersion": str + key "proxyUrlConfiguration": ForwardRef('ProxyUrlConfiguration', module='types') + key "tlsStatus": str + key "updateInfoDetails": str + key "updateRequestedDateTime": str + aggregated_status_code: int + aggregated_status_details: str + aggregated_status_text: str + app_version_wsl: str + auto_update_applied_version: str + auto_update_last_applied_date_time: str + auto_update_last_applied_details: str + auto_update_last_applied_state: str + auto_update_last_triggered_date_time: str + auto_update_next_available_date_time: str + auto_update_next_available_version: str + auto_update_version: str + bgp_configuration: BgpConfiguration + cacheNodePropertiesDetailsIssuesList: list[str] + cache_node_properties_details_issues_list: list[str] + cache_node_state: int + cache_node_state_detailed_text: str + cache_node_state_short_text: str + container_os_build: str + container_os_edition: str + container_os_version: str + creation_method: int + current_tls_certificate: MccCacheNodeTlsCertificate + distro_os_build_wsl: str + distro_os_edition_wsl: str + distro_os_version_wsl: str + driveConfiguration: list[CacheNodeDriveConfiguration] + drive_configuration: list[CacheNodeDriveConfiguration] + host_os_build: str + host_os_edition: str + host_os_version: str + install_version_msix: str + install_version_script: str + is_provisioned: bool + is_proxy_required: Union[str, ProxyRequired] + issuesList: list[str] + issues_count: int + issues_list: list[str] + last_auto_update_info: MccCacheNodeAutoUpdateInfo + optional_property1: str + optional_property2: str + optional_property3: str + optional_property4: str + optional_property5: str + os_type: Union[str, OsType] + product_version: str + proxy_url_configuration: ProxyUrlConfiguration + tls_status: str + update_info_details: str + update_requested_date_time: str + + + class azure.mgmt.connectedcache.types.AdditionalCustomerProperties(TypedDict, total=False): + key "customerAsn": str + key "customerAsnEstimatedEgressPeekGbps": float + key "customerEmail": str + key "customerEntitlementExpiration": str + key "customerEntitlementSkuGuid": str + key "customerEntitlementSkuId": str + key "customerEntitlementSkuName": str + key "customerOrgName": str + key "customerPropertiesOverviewAverageEgressMbps": float + key "customerPropertiesOverviewAverageMissMbps": float + key "customerPropertiesOverviewCacheEfficiency": float + key "customerPropertiesOverviewCacheNodesHealthyCount": int + key "customerPropertiesOverviewCacheNodesUnhealthyCount": int + key "customerPropertiesOverviewEgressMbpsMax": float + key "customerPropertiesOverviewEgressMbpsMaxDateTime": str + key "customerPropertiesOverviewMissMbpsMax": float + key "customerPropertiesOverviewMissMbpsMaxDateTime": str + key "customerTransitAsn": str + key "customerTransitState": Union[str, CustomerTransitState] + key "optionalProperty1": str + key "optionalProperty2": str + key "optionalProperty3": str + key "optionalProperty4": str + key "optionalProperty5": str + key "peeringDbLastUpdateDate": str + key "signupPhaseStatusCode": int + key "signupPhaseStatusText": str + key "signupStatus": bool + key "signupStatusCode": int + key "signupStatusText": str + customer_asn: str + customer_asn_estimated_egress_peek_gbps: float + customer_email: str + customer_entitlement_expiration: str + customer_entitlement_sku_guid: str + customer_entitlement_sku_id: str + customer_entitlement_sku_name: str + customer_org_name: str + customer_properties_overview_average_egress_mbps: float + customer_properties_overview_average_miss_mbps: float + customer_properties_overview_cache_efficiency: float + customer_properties_overview_cache_nodes_healthy_count: int + customer_properties_overview_cache_nodes_unhealthy_count: int + customer_properties_overview_egress_mbps_max: float + customer_properties_overview_egress_mbps_max_date_time: str + customer_properties_overview_miss_mbps_max: float + customer_properties_overview_miss_mbps_max_date_time: str + customer_transit_asn: str + customer_transit_state: Union[str, CustomerTransitState] + optional_property1: str + optional_property2: str + optional_property3: str + optional_property4: str + optional_property5: str + peering_db_last_update_date: str + signup_phase_status_code: int + signup_phase_status_text: str + signup_status: bool + signup_status_code: int + signup_status_text: str + + + class azure.mgmt.connectedcache.types.BgpConfiguration(TypedDict, total=False): + key "asnToIpAddressMapping": str + asn_to_ip_address_mapping: str + + + class azure.mgmt.connectedcache.types.CacheNodeDriveConfiguration(TypedDict, total=False): + key "cacheNumber": int + key "nginxMapping": str + key "physicalPath": str + key "sizeInGb": int + cache_number: int + nginx_mapping: str + physical_path: str + size_in_gb: int + + + class azure.mgmt.connectedcache.types.CacheNodeEntity(TypedDict, total=False): + key "addressSpace": int + key "autoUpdateRequestedDay": int + key "autoUpdateRequestedTime": str + key "autoUpdateRequestedWeek": int + key "autoUpdateRingType": Union[str, AutoUpdateRingType] + key "bgpAddressSpace": int + key "bgpCidrBlocksCount": int + key "bgpCidrCsvLastUpdateTime": str + key "bgpFileBytesTruncated": int + key "bgpLastReportedTime": str + key "bgpNetworkInterface": str + key "bgpNumberOfRecords": int + key "bgpNumberOfTimesUpdated": int + key "bgpReviewFeedback": str + key "bgpReviewState": Union[str, BgpReviewStateEnum] + key "bgpReviewStateText": str + key "cacheNodeId": str + key "cacheNodeName": str + key "category": str + key "cidrCsvLastUpdateTime": str + key "cidrSelectionType": int + key "clientTenantId": str + key "configurationState": Union[str, ConfigurationState] + key "configurationStateText": str + key "containerConfigurations": str + key "containerResyncTrigger": int + key "createAsyncOperationId": str + key "customerAsn": int + key "customerId": str + key "customerIndex": str + key "customerName": str + key "deleteAsyncOperationId": str + key "fullyQualifiedDomainName": str + key "fullyQualifiedResourceId": str + key "imageUri": str + key "ipAddress": str + key "isEnabled": bool + key "isEnterpriseManaged": bool + key "isFrozen": bool + key "lastSyncWithAzureTimestamp": str + key "lastUpdatedTimestamp": str + key "maxAllowableEgressInMbps": int + key "maxAllowableProbability": float + key "openFirewallPort443": bool + key "openFirewallPort5000": bool + key "openFirewallPort5001": bool + key "openFirewallPort80": bool + key "releaseVersion": int + key "reviewFeedback": str + key "reviewState": int + key "reviewStateText": str + key "runtimeAccountType": str + key "shouldMigrate": bool + key "synchWithAzureAttemptsCount": int + key "workerConnections": int + key "workerConnectionsLastUpdatedDateTime": str + key "xCid": str + address_space: int + auto_update_requested_day: int + auto_update_requested_time: str + auto_update_requested_week: int + auto_update_ring_type: Union[str, AutoUpdateRingType] + bgp_address_space: int + bgp_cidr_blocks_count: int + bgp_cidr_csv_last_update_time: str + bgp_file_bytes_truncated: int + bgp_last_reported_time: str + bgp_network_interface: str + bgp_number_of_records: int + bgp_number_of_times_updated: int + bgp_review_feedback: str + bgp_review_state: Union[str, BgpReviewStateEnum] + bgp_review_state_text: str + cache_node_id: str + cache_node_name: str + category: str + cidrCsv: list[str] + cidr_csv: list[str] + cidr_csv_last_update_time: str + cidr_selection_type: int + client_tenant_id: str + configuration_state: Union[str, ConfigurationState] + configuration_state_text: str + container_configurations: str + container_resync_trigger: int + create_async_operation_id: str + customer_asn: int + customer_id: str + customer_index: str + customer_name: str + delete_async_operation_id: str + fully_qualified_domain_name: str + fully_qualified_resource_id: str + image_uri: str + ip_address: str + is_enabled: bool + is_enterprise_managed: bool + is_frozen: bool + last_sync_with_azure_timestamp: str + last_updated_timestamp: str + max_allowable_egress_in_mbps: int + max_allowable_probability: float + open_firewall_port443: bool + open_firewall_port5000: bool + open_firewall_port5001: bool + open_firewall_port80: bool + release_version: int + review_feedback: str + review_state: int + review_state_text: str + runtime_account_type: str + should_migrate: bool + synch_with_azure_attempts_count: int + worker_connections: int + worker_connections_last_updated_date_time: str + x_cid: str + + + class azure.mgmt.connectedcache.types.CacheNodeProperty(TypedDict, total=False): + key "additionalCacheNodeProperties": ForwardRef('AdditionalCacheNodeProperties', module='types') + key "cacheNode": ForwardRef('CacheNodeEntity', module='types') + key "error": ForwardRef('ErrorDetail', module='types') + key "provisioningState": Union[str, ProvisioningState] + key "status": str + key "statusCode": str + key "statusDetails": str + key "statusText": str + additional_cache_node_properties: AdditionalCacheNodeProperties + cache_node: CacheNodeEntity + error: ErrorDetail + provisioning_state: Union[str, ProvisioningState] + status: str + status_code: str + status_details: str + status_text: str + + + class azure.mgmt.connectedcache.types.ConnectedCachePatchResource(TypedDict, total=False): + tags: dict[str, str] + + + class azure.mgmt.connectedcache.types.CustomerEntity(TypedDict, total=False): + key "clientTenantId": str + key "contactEmail": str + key "contactName": str + key "contactPhone": str + key "createAsyncOperationId": str + key "customerId": str + key "customerName": str + key "deleteAsyncOperationId": str + key "fullyQualifiedResourceId": str + key "isEnterpriseManaged": bool + key "isEntitled": bool + key "lastSyncWithAzureTimestamp": str + key "releaseVersion": int + key "resendSignupCode": bool + key "shouldMigrate": bool + key "synchWithAzureAttemptsCount": int + key "verifySignupCode": bool + key "verifySignupPhrase": str + client_tenant_id: str + contact_email: str + contact_name: str + contact_phone: str + create_async_operation_id: str + customer_id: str + customer_name: str + delete_async_operation_id: str + fully_qualified_resource_id: str + is_enterprise_managed: bool + is_entitled: bool + last_sync_with_azure_timestamp: str + release_version: int + resend_signup_code: bool + should_migrate: bool + synch_with_azure_attempts_count: int + verify_signup_code: bool + verify_signup_phrase: str + + + class azure.mgmt.connectedcache.types.CustomerProperty(TypedDict, total=False): + key "additionalCustomerProperties": ForwardRef('AdditionalCustomerProperties', module='types') + key "customer": ForwardRef('CustomerEntity', module='types') + key "error": ForwardRef('ErrorDetail', module='types') + key "provisioningState": Union[str, ProvisioningState] + key "status": str + key "statusCode": str + key "statusDetails": str + key "statusText": str + additional_customer_properties: AdditionalCustomerProperties + customer: CustomerEntity + error: ErrorDetail + provisioning_state: Union[str, ProvisioningState] + status: str + status_code: str + status_details: str + status_text: str + + + class azure.mgmt.connectedcache.types.EnterpriseMccCacheNodeResource(TrackedResource): + key "id": str + key "location": Required[str] + key "name": str + key "properties": ForwardRef('CacheNodeProperty', module='types') + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + location: str + name: str + properties: CacheNodeProperty + system_data: SystemData + tags: dict[str, str] + type: str + + + class azure.mgmt.connectedcache.types.EnterpriseMccCustomerResource(TrackedResource): + key "id": str + key "location": Required[str] + key "name": str + key "properties": ForwardRef('CustomerProperty', module='types') + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + location: str + name: str + properties: CustomerProperty + system_data: SystemData + tags: dict[str, str] + type: str + + + class azure.mgmt.connectedcache.types.ErrorAdditionalInfo(TypedDict, total=False): + key "info": Any + key "type": str + info: Any + type: str + + + class azure.mgmt.connectedcache.types.ErrorDetail(TypedDict, total=False): + key "code": str + key "message": str + key "target": str + additionalInfo: list[ErrorAdditionalInfo] + additional_info: list[ErrorAdditionalInfo] + code: str + details: list[ErrorDetail] + message: str + target: str + + + class azure.mgmt.connectedcache.types.IspCacheNodeResource(TrackedResource): + key "id": str + key "location": Required[str] + key "name": str + key "properties": ForwardRef('CacheNodeProperty', module='types') + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + location: str + name: str + properties: CacheNodeProperty + system_data: SystemData + tags: dict[str, str] + type: str + + + class azure.mgmt.connectedcache.types.IspCustomerResource(TrackedResource): + key "id": str + key "location": Required[str] + key "name": str + key "properties": ForwardRef('CustomerProperty', module='types') + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + location: str + name: str + properties: CustomerProperty + system_data: SystemData + tags: dict[str, str] + type: str + + + class azure.mgmt.connectedcache.types.MccCacheNodeAutoUpdateInfo(TypedDict, total=False): + key "autoUpdateLastAppliedStatus": int + key "autoUpdateLastAppliedStatusDetailedText": str + key "autoUpdateLastAppliedStatusText": str + key "autoUpdateRingType": int + key "createdDateTimeUtc": str + key "imageUriBeforeUpdate": str + key "imageUriTargeted": str + key "imageUriTerminal": str + key "movedToTerminalStateDateTime": str + key "planChangeLogText": str + key "planId": int + key "ruleRequestedDay": int + key "ruleRequestedHour": str + key "ruleRequestedMinute": str + key "ruleRequestedWeek": int + key "timeToGoLiveDateTime": str + key "updatedRegistryDateTimeUtc": str + auto_update_last_applied_status: int + auto_update_last_applied_status_detailed_text: str + auto_update_last_applied_status_text: str + auto_update_ring_type: int + created_date_time_utc: str + image_uri_before_update: str + image_uri_targeted: str + image_uri_terminal: str + moved_to_terminal_state_date_time: str + plan_change_log_text: str + plan_id: int + rule_requested_day: int + rule_requested_hour: str + rule_requested_minute: str + rule_requested_week: int + time_to_go_live_date_time: str + updated_registry_date_time_utc: str + + + class azure.mgmt.connectedcache.types.MccCacheNodeTlsCertificate(TypedDict, total=False): + key "actionRequired": str + key "certType": str + key "certificateFileName": str + key "expiryDate": str + key "notBeforeDate": str + key "subject": str + key "subjectAltName": str + key "thumbprint": str + action_required: str + cert_type: str + certificate_file_name: str + expiry_date: str + not_before_date: str + subject: str + subject_alt_name: str + thumbprint: str + + + class azure.mgmt.connectedcache.types.ProxyUrlConfiguration(TypedDict, total=False): + key "proxyUrl": str + proxy_url: str + + + class azure.mgmt.connectedcache.types.Resource(TypedDict, total=False): + key "id": str + key "name": str + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + name: str + system_data: SystemData + type: str + + + class azure.mgmt.connectedcache.types.SystemData(TypedDict, total=False): + key "createdAt": str + key "createdBy": str + key "createdByType": Union[str, CreatedByType] + key "lastModifiedAt": str + key "lastModifiedBy": str + key "lastModifiedByType": Union[str, CreatedByType] + created_at: str + created_by: str + created_by_type: Union[str, CreatedByType] + last_modified_at: str + last_modified_by: str + last_modified_by_type: Union[str, CreatedByType] + + + class azure.mgmt.connectedcache.types.TrackedResource(Resource): + key "id": str + key "location": Required[str] + key "name": str + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + location: str + name: str + system_data: SystemData + tags: dict[str, str] + type: str + + +``` \ No newline at end of file diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/api.metadata.yml b/sdk/connectedcache/azure-mgmt-connectedcache/api.metadata.yml new file mode 100644 index 000000000000..66bcca182f8e --- /dev/null +++ b/sdk/connectedcache/azure-mgmt-connectedcache/api.metadata.yml @@ -0,0 +1,3 @@ +apiMdSha256: c06bf917a2c13579e3568ab66326cf7dc971755c60e7f5428e6b76ca4c01b991 +parserVersion: 0.3.30 +pythonVersion: 3.13.14 diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/apiview-properties.json b/sdk/connectedcache/azure-mgmt-connectedcache/apiview-properties.json index 98821d2d6a55..8d389e67c1f9 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/apiview-properties.json +++ b/sdk/connectedcache/azure-mgmt-connectedcache/apiview-properties.json @@ -108,5 +108,6 @@ "azure.mgmt.connectedcache.aio.operations.EnterpriseMccCacheNodesOperationsOperations.get_cache_node_mcc_issue_details_history": "Microsoft.ConnectedCache.EnterpriseMccCacheNodesOperations.getCacheNodeMccIssueDetailsHistory", "azure.mgmt.connectedcache.operations.EnterpriseMccCacheNodesOperationsOperations.get_cache_node_tls_certificate_history": "Microsoft.ConnectedCache.EnterpriseMccCacheNodesOperations.getCacheNodeTlsCertificateHistory", "azure.mgmt.connectedcache.aio.operations.EnterpriseMccCacheNodesOperationsOperations.get_cache_node_tls_certificate_history": "Microsoft.ConnectedCache.EnterpriseMccCacheNodesOperations.getCacheNodeTlsCertificateHistory" - } + }, + "CrossLanguageVersion": "e7f15a6d1a0a" } \ No newline at end of file diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_client.py b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_client.py index b34b97e181a5..ed08cda7c836 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_client.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_client.py @@ -7,8 +7,8 @@ # -------------------------------------------------------------------------- from copy import deepcopy +import sys 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 @@ -27,13 +27,18 @@ Operations, ) +if sys.version_info >= (3, 11): + from typing import Self +else: + from typing_extensions import Self # type: ignore + if TYPE_CHECKING: from azure.core import AzureClouds from azure.core.credentials import TokenCredential class ConnectedCacheMgmtClient: - """Microsoft Connected Cache Rest Api version 2023-05-01-preview. + """Microsoft Connected Cache Rest APIs. :ivar operations: Operations operations :vartype operations: azure.mgmt.connectedcache.operations.Operations @@ -58,9 +63,9 @@ class ConnectedCacheMgmtClient: :keyword cloud_setting: The cloud setting for which to get the ARM endpoint. Default value is None. :paramtype cloud_setting: ~azure.core.AzureClouds - :keyword api_version: The API version to use for this operation. Default value is - "2024-11-30-preview". Note that overriding this default value may result in unsupported - behavior. + :keyword api_version: The API version to use for this operation. Known values are "2026-06-01" + and None. Default value is None. If not set, the operation's default API version will be used. + Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_configuration.py b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_configuration.py index 6a48a86d4383..c619a39d074c 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_configuration.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_configuration.py @@ -33,9 +33,9 @@ class ConnectedCacheMgmtClientConfiguration: # pylint: disable=too-many-instanc :param cloud_setting: The cloud setting for which to get the ARM endpoint. Default value is None. :type cloud_setting: ~azure.core.AzureClouds - :keyword api_version: The API version to use for this operation. Default value is - "2024-11-30-preview". Note that overriding this default value may result in unsupported - behavior. + :keyword api_version: The API version to use for this operation. Known values are "2026-06-01" + and None. Default value is None. If not set, the operation's default API version will be used. + Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ @@ -47,7 +47,7 @@ def __init__( cloud_setting: Optional["AzureClouds"] = None, **kwargs: Any ) -> None: - api_version: str = kwargs.pop("api_version", "2024-11-30-preview") + api_version: str = kwargs.pop("api_version", "2026-06-01") if credential is None: raise ValueError("Parameter 'credential' must not be None.") diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_utils/model_base.py b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_utils/model_base.py index 75b6936a909c..0f2c5bdfe70f 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_utils/model_base.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_utils/model_base.py @@ -23,20 +23,26 @@ from json import JSONEncoder import xml.etree.ElementTree as ET from collections.abc import MutableMapping -from typing_extensions import Self import isodate from azure.core.exceptions import DeserializationError from azure.core import CaseInsensitiveEnumMeta from azure.core.pipeline import PipelineResponse from azure.core.serialization import _Null + from azure.core.rest import HttpResponse +if sys.version_info >= (3, 11): + from typing import Self +else: + from typing_extensions import Self + _LOGGER = logging.getLogger(__name__) __all__ = ["SdkJSONEncoder", "Model", "rest_field", "rest_discriminator"] TZ_UTC = timezone.utc _T = typing.TypeVar("_T") +_NONE_TYPE = type(None) def _timedelta_as_isostr(td: timedelta) -> str: @@ -103,6 +109,29 @@ def _serialize_bytes(o, format: typing.Optional[str] = None) -> str: return encoded +def _serialize_duration(td: timedelta, format: typing.Optional[str] = None): + """Serialize a timedelta to its wire representation. + + For the ``seconds``/``milliseconds`` encodings the value is converted to a + numeric value, otherwise it falls back to an ISO 8601 duration string. + + :param timedelta td: The timedelta to serialize. + :param str format: The duration encoding format. + :rtype: int or float or str + :return: serialized duration + """ + seconds = td.total_seconds() + if format == "duration-seconds-int": + return int(seconds) + if format == "duration-seconds-float": + return seconds + if format == "duration-milliseconds-int": + return int(seconds * 1000) + if format == "duration-milliseconds-float": + return seconds * 1000 + return _timedelta_as_isostr(td) + + def _serialize_datetime(o, format: typing.Optional[str] = None): if hasattr(o, "year") and hasattr(o, "hour"): if format == "rfc7231": @@ -217,7 +246,7 @@ def _deserialize_datetime(attr: typing.Union[str, datetime]) -> datetime: test_utc = date_obj.utctimetuple() if test_utc.tm_year > 9999 or test_utc.tm_year < 1: raise OverflowError("Hit max or min date") - return date_obj + return date_obj # type: ignore[no-any-return] def _deserialize_datetime_rfc7231(attr: typing.Union[str, datetime]) -> datetime: @@ -271,7 +300,7 @@ def _deserialize_time(attr: typing.Union[str, time]) -> time: """ if isinstance(attr, time): return attr - return isodate.parse_time(attr) + return isodate.parse_time(attr) # type: ignore[no-any-return] def _deserialize_bytes(attr): @@ -295,6 +324,12 @@ def _deserialize_duration(attr): return isodate.parse_duration(attr) +def _deserialize_duration_numeric(attr, unit): + if isinstance(attr, timedelta): + return attr + return timedelta(**{unit: float(attr)}) + + def _deserialize_decimal(attr): if isinstance(attr, decimal.Decimal): return attr @@ -324,6 +359,10 @@ def _deserialize_int_as_str(attr): "unix-timestamp": _deserialize_datetime_unix_timestamp, "base64": _deserialize_bytes, "base64url": _deserialize_bytes_base64, + "duration-seconds-int": functools.partial(_deserialize_duration_numeric, unit="seconds"), + "duration-seconds-float": functools.partial(_deserialize_duration_numeric, unit="seconds"), + "duration-milliseconds-int": functools.partial(_deserialize_duration_numeric, unit="milliseconds"), + "duration-milliseconds-float": functools.partial(_deserialize_duration_numeric, unit="milliseconds"), } @@ -419,21 +458,21 @@ def __ne__(self, other: typing.Any) -> bool: def keys(self) -> typing.KeysView[str]: """ - :returns: a set-like object providing a view on D's keys + :returns: a set-like object providing a view on the mapping's keys :rtype: ~typing.KeysView """ return self._data.keys() def values(self) -> typing.ValuesView[typing.Any]: """ - :returns: an object providing a view on D's values + :returns: an object providing a view on the mapping's values :rtype: ~typing.ValuesView """ return self._data.values() def items(self) -> typing.ItemsView[str, typing.Any]: """ - :returns: set-like object providing a view on D's items + :returns: a set-like object providing a view on the mapping's items :rtype: ~typing.ItemsView """ return self._data.items() @@ -443,7 +482,7 @@ def get(self, key: str, default: typing.Any = None) -> typing.Any: Get the value for key if key is in the dictionary, else default. :param str key: The key to look up. :param any default: The value to return if key is not in the dictionary. Defaults to None - :returns: D[k] if k in D, else d. + :returns: The value for key if key is in the dictionary, else default. :rtype: any """ try: @@ -478,19 +517,19 @@ def popitem(self) -> tuple[str, typing.Any]: Removes and returns some (key, value) pair :returns: The (key, value) pair. :rtype: tuple - :raises KeyError: if D is empty. + :raises KeyError: if the dictionary is empty. """ return self._data.popitem() def clear(self) -> None: """ - Remove all items from D. + Remove all items from the dictionary. """ self._data.clear() def update(self, *args: typing.Any, **kwargs: typing.Any) -> None: # pylint: disable=arguments-differ """ - Updates D from mapping/iterable E and F. + Update the dictionary from a mapping or an iterable of key-value pairs. :param any args: Either a mapping object or an iterable of key-value pairs. """ self._data.update(*args, **kwargs) @@ -503,10 +542,11 @@ def setdefault(self, key: str, default: typing.Any) -> typing.Any: ... # pylint def setdefault(self, key: str, default: typing.Any = _UNSET) -> typing.Any: """ - Same as calling D.get(k, d), and setting D[k]=d if k not found + Return the value for key if key is in the dictionary; otherwise set the key to + default and return default. :param str key: The key to look up. :param any default: The value to set if key is not in the dictionary - :returns: D[k] if k in D, else d. + :returns: The value for key if key is in the dictionary, else default. :rtype: any """ if default is _UNSET: @@ -514,6 +554,8 @@ def setdefault(self, key: str, default: typing.Any = _UNSET) -> typing.Any: return self._data.setdefault(key, default) def __eq__(self, other: typing.Any) -> bool: + if isinstance(other, _MyMutableMapping): + return self._data == other._data try: other_model = self.__class__(other) except Exception: @@ -556,7 +598,7 @@ def _serialize(o, format: typing.Optional[str] = None): # pylint: disable=too-m pass # Last, try datetime.timedelta try: - return _timedelta_as_isostr(o) + return _serialize_duration(o, format) except AttributeError: # This will be raised when it hits value.total_seconds in the method above pass @@ -582,6 +624,239 @@ def _create_value(rf: typing.Optional["_RestField"], value: typing.Any) -> typin return _serialize(value, rf._format) +# ============================================================================ +# Fast-path scalar deserializer functions for rest_field(deserializer=...) +# These are referenced from rest_field declarations to bypass the generic +# _deserialize -> _deserialize_with_callable chain. +# Only simple/primitive types — no models or container types. +# ============================================================================ + + +def _xml_deser_str(value): + if isinstance(value, ET.Element): + return value.text or "" + return str(value) if value is not None else None + + +def _xml_deser_int(value): + if isinstance(value, ET.Element): + return int(value.text) if value.text else None + return int(value) if value is not None else None + + +def _xml_deser_float(value): + if isinstance(value, ET.Element): + return float(value.text) if value.text else None + return float(value) if value is not None else None + + +def _xml_deser_bool(value): + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + if text in (True, False): + return text + return text.lower() == "true" + + +# pylint: disable=docstring-missing-param +def _xml_deser_bytes(value): + """Deserialize bytes from XML (base64).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_bytes(text) + + +def _xml_deser_bytes_base64url(value): + """Deserialize bytes from XML (base64url).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_bytes_base64(text) + + +def _xml_deser_datetime(value): + """Deserialize a datetime from XML (ISO 8601 / rfc3339).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_datetime(text) + + +def _xml_deser_datetime_rfc7231(value): + """Deserialize a datetime from XML (RFC7231 format).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_datetime_rfc7231(text) + + +def _xml_deser_datetime_unix_timestamp(value): + """Deserialize a datetime from XML (Unix timestamp).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_datetime_unix_timestamp(float(text)) + + +def _xml_deser_date(value): + """Deserialize a date from XML (ISO 8601).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_date(text) + + +def _xml_deser_time(value): + """Deserialize a time from XML (ISO 8601).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_time(text) + + +def _xml_deser_duration(value): + """Deserialize a timedelta from XML (ISO 8601 duration).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_duration(text) + + +def _xml_deser_decimal(value): + """Deserialize a Decimal from XML.""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_decimal(text) + + +def _xml_deser_enum_or_str(enum_cls, value): + """Deserialize a Union[EnumType, str] from XML.""" + text = value.text if isinstance(value, ET.Element) else value + if text is None: + return None + try: + return enum_cls(text) + except ValueError: + return text + + +def _extract_xml_model_type(rf_type): + """Extract the concrete Model class from a resolved rf._type partial chain. + + Unwraps ``Optional[Model]`` and ``_deserialize_model(Model, ...)`` + wrappers. Only handles Model and Optional[Model] — other composite + types (List, Dict, Union, etc.) return None and fall through to the + generic ``_deserialize`` path at runtime. + """ + if rf_type is None: + return None + if isinstance(rf_type, type) and _is_model(rf_type): + return rf_type + if not isinstance(rf_type, functools.partial): + return None + func = rf_type.func + args = rf_type.args + if func is _deserialize_with_optional and args: + return _extract_xml_model_type(args[0]) + if func is _deserialize_model and args: + cls = args[0] + return cls if isinstance(cls, type) and _is_model(cls) else None + return None + + +def _build_xml_field_plan( # pylint: disable=docstring-missing-return, docstring-missing-rtype, unused-variable + cls, attr_to_rest_field: dict +) -> list: + """Build a precomputed XML field plan for fast _init_from_xml iteration. + + Called once per model class in __new__. Returns a list of tuples: + (rest_name, xml_name, kind, deser, rf_type, is_optional, items_name) + + kind: 0=wrapped, 1=attribute, 2=unwrapped, 3=text + + For Model and Optional[Model] fields that lack a scalar + ``_deserializer``, this function precomputes the Model class as the + deserializer so ``_init_from_xml`` can call ``ModelClass(element)`` + directly instead of going through the expensive + ``_get_deserialize_callable_from_annotation`` chain at runtime. + """ + model_meta = getattr(cls, "_xml", {}) + model_ns = model_meta.get("ns") or model_meta.get("namespace") + plan = [] + + for rf in attr_to_rest_field.values(): + prop_meta = getattr(rf, "_xml", {}) + deser = rf._deserializer + + xml_name = prop_meta.get("name", rf._rest_name) + xml_ns = _resolve_xml_ns(prop_meta, model_meta) + if xml_ns: + xml_name = "{" + xml_ns + "}" + xml_name + + is_optional = rf._is_optional + + # For Model / Optional[Model] fields without a scalar deserializer, + # precompute the Model class as the deserializer. + if deser is None and rf._type is not None: + model_cls = _extract_xml_model_type(rf._type) + if model_cls is not None: + deser = model_cls + + if prop_meta.get("attribute", False): + plan.append((rf._rest_name, xml_name, 1, deser, rf._type, is_optional, None)) + elif prop_meta.get("unwrapped", False): + items_name = prop_meta.get("itemsName") + if items_name: + items_ns = prop_meta.get("itemsNs") + if items_ns is not None: + xml_ns = items_ns + if xml_ns: + items_name = "{" + xml_ns + "}" + items_name + else: + items_name = xml_name + plan.append((rf._rest_name, xml_name, 2, deser, rf._type, is_optional, items_name)) + elif prop_meta.get("text", False): + plan.append((rf._rest_name, xml_name, 3, deser, rf._type, is_optional, None)) + else: + plan.append((rf._rest_name, xml_name, 0, deser, rf._type, is_optional, None)) + + return plan + + +# pylint: enable=docstring-missing-param class Model(_MyMutableMapping): _is_model = True # label whether current class's _attr_to_rest_field has been calculated @@ -592,59 +867,10 @@ def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None: class_name = self.__class__.__name__ if len(args) > 1: raise TypeError(f"{class_name}.__init__() takes 2 positional arguments but {len(args) + 1} were given") - dict_to_pass = { - rest_field._rest_name: rest_field._default - for rest_field in self._attr_to_rest_field.values() - if rest_field._default is not _UNSET - } - if args: # pylint: disable=too-many-nested-blocks + dict_to_pass: dict[str, typing.Any] = {} + if args: if isinstance(args[0], ET.Element): - existed_attr_keys = [] - model_meta = getattr(self, "_xml", {}) - - for rf in self._attr_to_rest_field.values(): - prop_meta = getattr(rf, "_xml", {}) - xml_name = prop_meta.get("name", rf._rest_name) - xml_ns = prop_meta.get("ns", model_meta.get("ns", None)) - if xml_ns: - xml_name = "{" + xml_ns + "}" + xml_name - - # attribute - if prop_meta.get("attribute", False) and args[0].get(xml_name) is not None: - existed_attr_keys.append(xml_name) - dict_to_pass[rf._rest_name] = _deserialize(rf._type, args[0].get(xml_name)) - continue - - # unwrapped element is array - if prop_meta.get("unwrapped", False): - # unwrapped array could either use prop items meta/prop meta - if prop_meta.get("itemsName"): - xml_name = prop_meta.get("itemsName") - xml_ns = prop_meta.get("itemNs") - if xml_ns: - xml_name = "{" + xml_ns + "}" + xml_name - items = args[0].findall(xml_name) # pyright: ignore - if len(items) > 0: - existed_attr_keys.append(xml_name) - dict_to_pass[rf._rest_name] = _deserialize(rf._type, items) - continue - - # text element is primitive type - if prop_meta.get("text", False): - if args[0].text is not None: - dict_to_pass[rf._rest_name] = _deserialize(rf._type, args[0].text) - continue - - # wrapped element could be normal property or array, it should only have one element - item = args[0].find(xml_name) - if item is not None: - existed_attr_keys.append(xml_name) - dict_to_pass[rf._rest_name] = _deserialize(rf._type, item) - - # rest thing is additional properties - for e in args[0]: - if e.tag not in existed_attr_keys: - dict_to_pass[e.tag] = _convert_element(e) + dict_to_pass.update(self._init_from_xml(args[0])) else: dict_to_pass.update( {k: _create_value(_get_rest_field(self._attr_to_rest_field, k), v) for k, v in args[0].items()} @@ -661,8 +887,117 @@ def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None: if v is not None } ) + # Apply client default values for fields the caller didn't set so that + # defaults are part of `_data` and therefore included during serialization. + for rf in self._attr_to_rest_field.values(): + if rf._default is _UNSET: + continue + if rf._rest_name in dict_to_pass: + continue + dict_to_pass[rf._rest_name] = _create_value(rf, rf._default) super().__init__(dict_to_pass) + def _init_from_xml( # pylint: disable=too-many-branches, too-many-statements + self, element: ET.Element + ) -> dict[str, typing.Any]: + """Deserialize an XML element into a dict mapping rest field names to values. + + :param ET.Element element: The XML element to deserialize from. + :returns: A dictionary of rest_name to deserialized value pairs. + :rtype: dict + """ + result: dict[str, typing.Any] = {} + existed_attr_keys: list[str] = [] + + field_plan = getattr(self, "_xml_field_plan", None) + if field_plan: + for rest_name, xml_name, kind, deser, rf_type, is_optional, items_name in field_plan: + if kind == 0: # wrapped element (most common) + item = element.find(xml_name) + if item is not None: + existed_attr_keys.append(xml_name) + if deser: + result[rest_name] = deser(item) + else: + result[rest_name] = _deserialize(rf_type, item) + elif kind == 1: # attribute + attr_val = element.get(xml_name) + if attr_val is not None: + existed_attr_keys.append(xml_name) + if deser: + result[rest_name] = deser(attr_val) + else: + result[rest_name] = attr_val + elif kind == 2: # unwrapped array + items = element.findall(items_name) # pyright: ignore + if len(items) > 0: + existed_attr_keys.append(items_name) + if deser: + result[rest_name] = deser(items) + else: + result[rest_name] = _deserialize(rf_type, items) + elif not is_optional: + existed_attr_keys.append(items_name) + result[rest_name] = [] + elif kind == 3: # text + if element.text is not None: + if deser: + result[rest_name] = deser(element.text) + else: + result[rest_name] = element.text + else: + model_meta = getattr(self, "_xml", {}) + for rf in self._attr_to_rest_field.values(): + prop_meta = getattr(rf, "_xml", {}) + xml_name = prop_meta.get("name", rf._rest_name) + xml_ns = _resolve_xml_ns(prop_meta, model_meta) + if xml_ns: + xml_name = "{" + xml_ns + "}" + xml_name + + # attribute + if prop_meta.get("attribute", False) and element.get(xml_name) is not None: + existed_attr_keys.append(xml_name) + result[rf._rest_name] = _deserialize(rf._type, element.get(xml_name)) + continue + + # unwrapped element is array + if prop_meta.get("unwrapped", False): + _items_name = prop_meta.get("itemsName") + if _items_name: + xml_name = _items_name + _items_ns = prop_meta.get("itemsNs") + if _items_ns is not None: + xml_ns = _items_ns + if xml_ns: + xml_name = "{" + xml_ns + "}" + xml_name + items = element.findall(xml_name) # pyright: ignore + if len(items) > 0: + existed_attr_keys.append(xml_name) + result[rf._rest_name] = _deserialize(rf._type, items) + elif not rf._is_optional: + existed_attr_keys.append(xml_name) + result[rf._rest_name] = [] + continue + + # text element is primitive type + if prop_meta.get("text", False): + if element.text is not None: + result[rf._rest_name] = _deserialize(rf._type, element.text) + continue + + # wrapped element could be normal property or array + item = element.find(xml_name) + if item is not None: + existed_attr_keys.append(xml_name) + result[rf._rest_name] = _deserialize(rf._type, item) + + # rest thing is additional properties + for e in element: + if e.tag not in existed_attr_keys: + result[e.tag] = _convert_element(e) + + return result + def copy(self) -> "Model": return Model(self.__dict__) @@ -687,6 +1022,9 @@ def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> Self: if not rf._rest_name_input: rf._rest_name_input = attr cls._attr_to_rest_field: dict[str, _RestField] = dict(attr_to_rest_field.items()) + # Build XML field plan for fast _init_from_xml (only for XML models) + if getattr(cls, "_xml", None): + cls._xml_field_plan = _build_xml_field_plan(cls, attr_to_rest_field) cls._calculated.add(f"{cls.__module__}.{cls.__qualname__}") return super().__new__(cls) @@ -715,7 +1053,7 @@ def _deserialize(cls, data, exist_discriminators): model_meta = getattr(cls, "_xml", {}) prop_meta = getattr(discriminator, "_xml", {}) xml_name = prop_meta.get("name", discriminator._rest_name) - xml_ns = prop_meta.get("ns", model_meta.get("ns", None)) + xml_ns = _resolve_xml_ns(prop_meta, model_meta) if xml_ns: xml_name = "{" + xml_ns + "}" + xml_name @@ -807,6 +1145,14 @@ def _deserialize_multiple_sequence( return type(obj)(_deserialize(deserializer, entry, module) for entry, deserializer in zip(obj, entry_deserializers)) +def _is_array_encoded_deserializer(deserializer: functools.partial) -> bool: + return ( + isinstance(deserializer, functools.partial) + and isinstance(deserializer.args[0], functools.partial) + and deserializer.args[0].func == _deserialize_array_encoded # pylint: disable=comparison-with-callable + ) + + def _deserialize_sequence( deserializer: typing.Optional[typing.Callable], module: typing.Optional[str], @@ -816,17 +1162,19 @@ def _deserialize_sequence( return obj if isinstance(obj, ET.Element): obj = list(obj) - try: - if ( - isinstance(obj, str) - and isinstance(deserializer, functools.partial) - and isinstance(deserializer.args[0], functools.partial) - and deserializer.args[0].func == _deserialize_array_encoded # pylint: disable=comparison-with-callable - ): - # encoded string may be deserialized to sequence + + # encoded string may be deserialized to sequence + if isinstance(obj, str) and isinstance(deserializer, functools.partial): + # for list[str] + if _is_array_encoded_deserializer(deserializer): return deserializer(obj) - except: # pylint: disable=bare-except - pass + + # for list[Union[...]] + if isinstance(deserializer.args[0], list): + for sub_deserializer in deserializer.args[0]: + if _is_array_encoded_deserializer(sub_deserializer): + return sub_deserializer(obj) + return type(obj)(_deserialize(deserializer, entry, module) for entry in obj) @@ -877,16 +1225,18 @@ def _get_deserialize_callable_from_annotation( # pylint: disable=too-many-retur # is it optional? try: - if any(a for a in annotation.__args__ if a == type(None)): # pyright: ignore + if any(a is _NONE_TYPE for a in annotation.__args__): # pyright: ignore + if rf: + rf._is_optional = True if len(annotation.__args__) <= 2: # pyright: ignore if_obj_deserializer = _get_deserialize_callable_from_annotation( - next(a for a in annotation.__args__ if a != type(None)), module, rf # pyright: ignore + next(a for a in annotation.__args__ if a is not _NONE_TYPE), module, rf # pyright: ignore ) return functools.partial(_deserialize_with_optional, if_obj_deserializer) # the type is Optional[Union[...]], we need to remove the None type from the Union annotation_copy = copy.copy(annotation) - annotation_copy.__args__ = [a for a in annotation_copy.__args__ if a != type(None)] # pyright: ignore + annotation_copy.__args__ = [a for a in annotation_copy.__args__ if a is not _NONE_TYPE] # pyright: ignore return _get_deserialize_callable_from_annotation(annotation_copy, module, rf) except AttributeError: pass @@ -970,16 +1320,20 @@ def _deserialize_with_callable( return float(value.text) if value.text else None if deserializer is bool: return value.text == "true" if value.text else None + if deserializer and deserializer in _DESERIALIZE_MAPPING.values(): + return deserializer(value.text) if value.text else None + if deserializer and deserializer in _DESERIALIZE_MAPPING_WITHFORMAT.values(): + return deserializer(value.text) if value.text else None if deserializer is None: return value if deserializer in [int, float, bool]: return deserializer(value) if isinstance(deserializer, CaseInsensitiveEnumMeta): try: - return deserializer(value) + return deserializer(value.text if isinstance(value, ET.Element) else value) except ValueError: # for unknown value, return raw value - return value + return value.text if isinstance(value, ET.Element) else value if isinstance(deserializer, type) and issubclass(deserializer, Model): return deserializer._deserialize(value, []) return typing.cast(typing.Callable[[typing.Any], typing.Any], deserializer)(value) @@ -1012,7 +1366,7 @@ def _failsafe_deserialize( ) -> typing.Any: try: return _deserialize(deserializer, response.json(), module, rf, format) - except DeserializationError: + except Exception: # pylint: disable=broad-except _LOGGER.warning( "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True ) @@ -1025,13 +1379,14 @@ def _failsafe_deserialize_xml( ) -> typing.Any: try: return _deserialize_xml(deserializer, response.text()) - except DeserializationError: + except Exception: # pylint: disable=broad-except _LOGGER.warning( "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True ) return None +# pylint: disable=too-many-instance-attributes class _RestField: def __init__( self, @@ -1044,6 +1399,7 @@ def __init__( format: typing.Optional[str] = None, is_multipart_file_input: bool = False, xml: typing.Optional[dict[str, typing.Any]] = None, + deserializer: typing.Optional[typing.Callable] = None, ): self._type = type self._rest_name_input = name @@ -1051,10 +1407,12 @@ def __init__( self._is_discriminator = is_discriminator self._visibility = visibility self._is_model = False + self._is_optional = False self._default = default self._format = format self._is_multipart_file_input = is_multipart_file_input self._xml = xml if xml is not None else {} + self._deserializer = deserializer @property def _class_type(self) -> typing.Any: @@ -1074,7 +1432,10 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin # by this point, type and rest_name will have a value bc we default # them in __new__ of the Model class # Use _data.get() directly to avoid triggering __getitem__ which clears the cache - item = obj._data.get(self._rest_name) + item = obj._data.get(self._rest_name, _UNSET) + if item is _UNSET: + # Field not set by user; return the client default if one exists, otherwise None + return self._default if self._default is not _UNSET else None if item is None: return item if self._is_model: @@ -1087,7 +1448,11 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin # Return the value from _data directly (it's been deserialized in place) return obj._data.get(self._rest_name) - deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + # Fast path: use _deserializer directly (avoids _serialize/_deserialize chain) + if self._deserializer: + deserialized = self._deserializer(item) + else: + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) # For mutable types, store the deserialized value back in _data # so mutations directly affect _data @@ -1133,6 +1498,7 @@ def rest_field( format: typing.Optional[str] = None, is_multipart_file_input: bool = False, xml: typing.Optional[dict[str, typing.Any]] = None, + deserializer: typing.Optional[typing.Callable] = None, ) -> typing.Any: return _RestField( name=name, @@ -1142,6 +1508,7 @@ def rest_field( format=format, is_multipart_file_input=is_multipart_file_input, xml=xml, + deserializer=deserializer, ) @@ -1166,6 +1533,56 @@ def serialize_xml(model: Model, exclude_readonly: bool = False) -> str: return ET.tostring(_get_element(model, exclude_readonly), encoding="unicode") # type: ignore +def _get_xml_ns(meta: dict[str, typing.Any]) -> typing.Optional[str]: + """Return the XML namespace from a metadata dict, checking both 'ns' (old-style) and 'namespace' (DPG) keys. + + :param dict meta: The metadata dictionary to extract namespace from. + :returns: The namespace string if 'ns' or 'namespace' key is present, None otherwise. + :rtype: str or None + """ + ns = meta.get("ns") + if ns is None: + ns = meta.get("namespace") + return ns + + +def _resolve_xml_ns( + prop_meta: dict[str, typing.Any], model_meta: typing.Optional[dict[str, typing.Any]] = None +) -> typing.Optional[str]: + """Resolve XML namespace for a property, falling back to model namespace when appropriate. + + Checks the property metadata first; if no namespace is found and the model does not declare + an explicit prefix, falls back to the model-level namespace. + + :param dict prop_meta: The property metadata dictionary. + :param dict model_meta: The model metadata dictionary, used as fallback. + :returns: The resolved namespace string, or None. + :rtype: str or None + """ + ns = _get_xml_ns(prop_meta) + if ns is None and model_meta is not None and not model_meta.get("prefix"): + ns = _get_xml_ns(model_meta) + return ns + + +def _set_xml_attribute(element: ET.Element, name: str, value: typing.Any, prop_meta: dict[str, typing.Any]) -> None: + """Set an XML attribute on an element, handling namespace prefix registration. + + :param ET.Element element: The element to set the attribute on. + :param str name: The default attribute name (wire name). + :param any value: The attribute value. + :param dict prop_meta: The property metadata dictionary. + """ + xml_name = prop_meta.get("name", name) + _attr_ns = _get_xml_ns(prop_meta) + if _attr_ns: + _attr_prefix = prop_meta.get("prefix") + if _attr_prefix: + _safe_register_namespace(_attr_prefix, _attr_ns) + xml_name = "{" + _attr_ns + "}" + xml_name + element.set(xml_name, _get_primitive_type_value(value)) + + def _get_element( o: typing.Any, exclude_readonly: bool = False, @@ -1177,10 +1594,16 @@ def _get_element( # if prop is a model, then use the prop element directly, else generate a wrapper of model if wrapped_element is None: + # When serializing as an array item (parent_meta is set), check if the parent has an + # explicit itemsName. This ensures correct element names for unwrapped arrays (where + # the element tag is the property/items name, not the model type name). + _items_name = parent_meta.get("itemsName") if parent_meta is not None else None + element_name = _items_name if _items_name else (model_meta.get("name") or o.__class__.__name__) + _model_ns = _get_xml_ns(model_meta) wrapped_element = _create_xml_element( - model_meta.get("name", o.__class__.__name__), + element_name, model_meta.get("prefix"), - model_meta.get("ns"), + _model_ns, ) readonly_props = [] @@ -1202,7 +1625,9 @@ def _get_element( # additional properties will not have rest field, use the wire name as xml name prop_meta = {"name": k} - # if no ns for prop, use model's + # Propagate model namespace to properties only for old-style "ns"-keyed models. + # DPG-generated models use the "namespace" key and explicitly declare namespace on + # each property that needs it, so propagation is intentionally skipped for them. if prop_meta.get("ns") is None and model_meta.get("ns"): prop_meta["ns"] = model_meta.get("ns") prop_meta["prefix"] = model_meta.get("prefix") @@ -1214,12 +1639,7 @@ def _get_element( # text could only set on primitive type wrapped_element.text = _get_primitive_type_value(v) elif prop_meta.get("attribute", False): - xml_name = prop_meta.get("name", k) - if prop_meta.get("ns"): - ET.register_namespace(prop_meta.get("prefix"), prop_meta.get("ns")) # pyright: ignore - xml_name = "{" + prop_meta.get("ns") + "}" + xml_name # pyright: ignore - # attribute should be primitive type - wrapped_element.set(xml_name, _get_primitive_type_value(v)) + _set_xml_attribute(wrapped_element, k, v, prop_meta) else: # other wrapped prop element wrapped_element.append(_get_wrapped_element(v, exclude_readonly, prop_meta)) @@ -1228,6 +1648,7 @@ def _get_element( return [_get_element(x, exclude_readonly, parent_meta) for x in o] # type: ignore if isinstance(o, dict): result = [] + _dict_ns = _get_xml_ns(parent_meta) if parent_meta else None for k, v in o.items(): result.append( _get_wrapped_element( @@ -1235,7 +1656,7 @@ def _get_element( exclude_readonly, { "name": k, - "ns": parent_meta.get("ns") if parent_meta else None, + "ns": _dict_ns, "prefix": parent_meta.get("prefix") if parent_meta else None, }, ) @@ -1244,13 +1665,16 @@ def _get_element( # primitive case need to create element based on parent_meta if parent_meta: + _items_ns = parent_meta.get("itemsNs") + if _items_ns is None: + _items_ns = _get_xml_ns(parent_meta) return _get_wrapped_element( o, exclude_readonly, { "name": parent_meta.get("itemsName", parent_meta.get("name")), "prefix": parent_meta.get("itemsPrefix", parent_meta.get("prefix")), - "ns": parent_meta.get("itemsNs", parent_meta.get("ns")), + "ns": _items_ns, }, ) @@ -1262,8 +1686,9 @@ def _get_wrapped_element( exclude_readonly: bool, meta: typing.Optional[dict[str, typing.Any]], ) -> ET.Element: + _meta_ns = _get_xml_ns(meta) if meta else None wrapped_element = _create_xml_element( - meta.get("name") if meta else None, meta.get("prefix") if meta else None, meta.get("ns") if meta else None + meta.get("name") if meta else None, meta.get("prefix") if meta else None, _meta_ns ) if isinstance(v, (dict, list)): wrapped_element.extend(_get_element(v, exclude_readonly, meta)) @@ -1271,7 +1696,7 @@ def _get_wrapped_element( _get_element(v, exclude_readonly, meta, wrapped_element) else: wrapped_element.text = _get_primitive_type_value(v) - return wrapped_element + return wrapped_element # type: ignore[no-any-return] def _get_primitive_type_value(v) -> str: @@ -1284,9 +1709,29 @@ def _get_primitive_type_value(v) -> str: return str(v) -def _create_xml_element(tag, prefix=None, ns=None): - if prefix and ns: +def _safe_register_namespace(prefix: str, ns: str) -> None: + """Register an XML namespace prefix, handling reserved prefix patterns. + + Some prefixes (e.g. 'ns2') match Python's reserved 'ns\\d+' pattern used for + auto-generated prefixes, causing register_namespace to raise ValueError. + Falls back to directly registering in the internal namespace map. + + :param str prefix: The namespace prefix to register. + :param str ns: The namespace URI. + """ + try: ET.register_namespace(prefix, ns) + except ValueError: + _ns_map = getattr(ET, "_namespace_map", None) + if _ns_map is not None: + _ns_map[ns] = prefix + + +def _create_xml_element( + tag: typing.Any, prefix: typing.Optional[str] = None, ns: typing.Optional[str] = None +) -> ET.Element: + if prefix and ns: + _safe_register_namespace(prefix, ns) if ns: return ET.Element("{" + ns + "}" + tag) return ET.Element(tag) @@ -1297,6 +1742,8 @@ def _deserialize_xml( value: str, ) -> typing.Any: element = ET.fromstring(value) # nosec + if _is_model(deserializer): + return deserializer._deserialize(element, []) return _deserialize(deserializer, element) diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_utils/serialization.py b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_utils/serialization.py index 81ec1de5922b..75906e2eb77f 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_utils/serialization.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_utils/serialization.py @@ -39,11 +39,15 @@ import xml.etree.ElementTree as ET import isodate # type: ignore -from typing_extensions import Self from azure.core.exceptions import DeserializationError, SerializationError from azure.core.serialization import NULL as CoreNull +if sys.version_info >= (3, 11): + from typing import Self +else: + from typing_extensions import Self + _BOM = codecs.BOM_UTF8.decode(encoding="utf-8") JSON = MutableMapping[str, Any] @@ -516,6 +520,10 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: "rfc-1123": Serializer.serialize_rfc, "unix-time": Serializer.serialize_unix, "duration": Serializer.serialize_duration, + "duration-seconds-int": Serializer.serialize_duration_seconds_int, + "duration-seconds-float": Serializer.serialize_duration_seconds_float, + "duration-milliseconds-int": Serializer.serialize_duration_milliseconds_int, + "duration-milliseconds-float": Serializer.serialize_duration_milliseconds_float, "date": Serializer.serialize_date, "time": Serializer.serialize_time, "decimal": Serializer.serialize_decimal, @@ -1105,6 +1113,61 @@ def serialize_duration(attr, **kwargs): # pylint: disable=unused-argument attr = isodate.parse_duration(attr) return isodate.duration_isoformat(attr) + @staticmethod + def _serialize_duration_numeric(attr, scale, as_int): + """Serialize a TimeDelta into a numeric value scaled to the wire unit. + + :param TimeDelta attr: Object to be serialized. + :param int scale: Multiplier applied to total seconds (1 for seconds, 1000 for milliseconds). + :param bool as_int: Whether to truncate the result to an int. + :rtype: int or float + :return: serialized duration + """ + if isinstance(attr, str): + attr = isodate.parse_duration(attr) + value = attr.total_seconds() * scale if isinstance(attr, datetime.timedelta) else attr + return int(value) if as_int else float(value) + + @staticmethod + def serialize_duration_seconds_int(attr, **kwargs): # pylint: disable=unused-argument + """Serialize TimeDelta object into an integer number of seconds. + + :param TimeDelta attr: Object to be serialized. + :rtype: int + :return: serialized duration + """ + return Serializer._serialize_duration_numeric(attr, 1, True) + + @staticmethod + def serialize_duration_seconds_float(attr, **kwargs): # pylint: disable=unused-argument + """Serialize TimeDelta object into a floating point number of seconds. + + :param TimeDelta attr: Object to be serialized. + :rtype: float + :return: serialized duration + """ + return Serializer._serialize_duration_numeric(attr, 1, False) + + @staticmethod + def serialize_duration_milliseconds_int(attr, **kwargs): # pylint: disable=unused-argument + """Serialize TimeDelta object into an integer number of milliseconds. + + :param TimeDelta attr: Object to be serialized. + :rtype: int + :return: serialized duration + """ + return Serializer._serialize_duration_numeric(attr, 1000, True) + + @staticmethod + def serialize_duration_milliseconds_float(attr, **kwargs): # pylint: disable=unused-argument + """Serialize TimeDelta object into a floating point number of milliseconds. + + :param TimeDelta attr: Object to be serialized. + :rtype: float + :return: serialized duration + """ + return Serializer._serialize_duration_numeric(attr, 1000, False) + @staticmethod def serialize_rfc(attr, **kwargs): # pylint: disable=unused-argument """Serialize Datetime object into RFC-1123 formatted string. @@ -1377,6 +1440,10 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: "rfc-1123": Deserializer.deserialize_rfc, "unix-time": Deserializer.deserialize_unix, "duration": Deserializer.deserialize_duration, + "duration-seconds-int": Deserializer.deserialize_duration_seconds, + "duration-seconds-float": Deserializer.deserialize_duration_seconds, + "duration-milliseconds-int": Deserializer.deserialize_duration_milliseconds, + "duration-milliseconds-float": Deserializer.deserialize_duration_milliseconds, "date": Deserializer.deserialize_date, "time": Deserializer.deserialize_time, "decimal": Deserializer.deserialize_decimal, @@ -1389,6 +1456,10 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: } self.deserialize_expected_types = { "duration": (isodate.Duration, datetime.timedelta), + "duration-seconds-int": (isodate.Duration, datetime.timedelta), + "duration-seconds-float": (isodate.Duration, datetime.timedelta), + "duration-milliseconds-int": (isodate.Duration, datetime.timedelta), + "duration-milliseconds-float": (isodate.Duration, datetime.timedelta), "iso-8601": (datetime.datetime), } self.dependencies: dict[str, type] = dict(classes) if classes else {} @@ -1401,7 +1472,7 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: # Otherwise, result are unexpected self.additional_properties_detection = True - def __call__(self, target_obj, response_data, content_type=None): + def __call__(self, target_obj, response_data, content_type=None): # pylint: disable=too-many-return-statements """Call the deserializer to process a REST response. :param str target_obj: Target data type to deserialize to. @@ -1411,6 +1482,27 @@ def __call__(self, target_obj, response_data, content_type=None): :return: Deserialized object. :rtype: object """ + # Fast path for header deserialization: response_data is a plain str or None + # and target_obj is a simple scalar type. This avoids the expensive + # _unpack_content → _deserialize → _classify_target → deserialize_data chain. + if response_data is None: + return None + if target_obj == "str" and isinstance(response_data, str): + return response_data + if isinstance(response_data, str): + if target_obj == "int": + return int(response_data) + if target_obj == "bool": + if response_data in ("true", "1", "True"): + return True + if response_data in ("false", "0", "False"): + return False + return bool(response_data) + if target_obj == "rfc-1123": + return Deserializer.deserialize_rfc(response_data) + if target_obj == "bytearray": + return Deserializer.deserialize_bytearray(response_data) + data = self._unpack_content(response_data, content_type) return self._deserialize(target_obj, data) @@ -1929,6 +2021,48 @@ def deserialize_duration(attr): raise DeserializationError(msg) from err return duration + @staticmethod + def _deserialize_duration_numeric(attr, unit): + """Deserialize a numeric duration value into a TimeDelta object. + + :param float attr: response value to be deserialized. + :param str unit: The wire unit, used as the ``timedelta`` keyword + (``"seconds"`` or ``"milliseconds"``). + :return: Deserialized duration + :rtype: TimeDelta + :raises DeserializationError: if value is invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + duration = datetime.timedelta(**{unit: float(attr)}) # type: ignore + except (ValueError, OverflowError, TypeError) as err: + msg = "Cannot deserialize duration object." + raise DeserializationError(msg) from err + return duration + + @staticmethod + def deserialize_duration_seconds(attr): + """Deserialize a numeric number of seconds into a TimeDelta object. + + :param float attr: response value to be deserialized. + :return: Deserialized duration + :rtype: TimeDelta + :raises DeserializationError: if value is invalid. + """ + return Deserializer._deserialize_duration_numeric(attr, "seconds") + + @staticmethod + def deserialize_duration_milliseconds(attr): + """Deserialize a numeric number of milliseconds into a TimeDelta object. + + :param float attr: response value to be deserialized. + :return: Deserialized duration + :rtype: TimeDelta + :raises DeserializationError: if value is invalid. + """ + return Deserializer._deserialize_duration_numeric(attr, "milliseconds") + @staticmethod def deserialize_date(attr): """Deserialize ISO-8601 formatted string into Date object. diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_version.py b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_version.py index bbcd28b4aa67..c43fdbc2e239 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_version.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "1.0.0b2" +VERSION = "1.0.0b3" diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/aio/_client.py b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/aio/_client.py index 1e240dd04441..4eb5249b4fca 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/aio/_client.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/aio/_client.py @@ -7,8 +7,8 @@ # -------------------------------------------------------------------------- from copy import deepcopy +import sys 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 @@ -27,13 +27,18 @@ Operations, ) +if sys.version_info >= (3, 11): + from typing import Self +else: + from typing_extensions import Self # type: ignore + if TYPE_CHECKING: from azure.core import AzureClouds from azure.core.credentials_async import AsyncTokenCredential class ConnectedCacheMgmtClient: - """Microsoft Connected Cache Rest Api version 2023-05-01-preview. + """Microsoft Connected Cache Rest APIs. :ivar operations: Operations operations :vartype operations: azure.mgmt.connectedcache.aio.operations.Operations @@ -58,9 +63,9 @@ class ConnectedCacheMgmtClient: :keyword cloud_setting: The cloud setting for which to get the ARM endpoint. Default value is None. :paramtype cloud_setting: ~azure.core.AzureClouds - :keyword api_version: The API version to use for this operation. Default value is - "2024-11-30-preview". Note that overriding this default value may result in unsupported - behavior. + :keyword api_version: The API version to use for this operation. Known values are "2026-06-01" + and None. Default value is None. If not set, the operation's default API version will be used. + Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/aio/_configuration.py b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/aio/_configuration.py index 5f4be314fe05..9f5375917d75 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/aio/_configuration.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/aio/_configuration.py @@ -33,9 +33,9 @@ class ConnectedCacheMgmtClientConfiguration: # pylint: disable=too-many-instanc :param cloud_setting: The cloud setting for which to get the ARM endpoint. Default value is None. :type cloud_setting: ~azure.core.AzureClouds - :keyword api_version: The API version to use for this operation. Default value is - "2024-11-30-preview". Note that overriding this default value may result in unsupported - behavior. + :keyword api_version: The API version to use for this operation. Known values are "2026-06-01" + and None. Default value is None. If not set, the operation's default API version will be used. + Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ @@ -47,7 +47,7 @@ def __init__( cloud_setting: Optional["AzureClouds"] = None, **kwargs: Any ) -> None: - api_version: str = kwargs.pop("api_version", "2024-11-30-preview") + api_version: str = kwargs.pop("api_version", "2026-06-01") if credential is None: raise ValueError("Parameter 'credential' must not be None.") diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/aio/operations/_operations.py b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/aio/operations/_operations.py index 80fb76eb3b7e..114d9773c1d5 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/aio/operations/_operations.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/aio/operations/_operations.py @@ -33,7 +33,7 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling -from ... import models as _models +from ... import models as _models, types as _types from ..._utils.model_base import SdkJSONEncoder, _deserialize, _failsafe_deserialize from ..._utils.serialization import Deserializer, Serializer from ..._validation import api_version_validation @@ -74,7 +74,6 @@ T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, dict[str, Any]], Any]] -JSON = MutableMapping[str, Any] List = list @@ -142,7 +141,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -155,7 +157,10 @@ def prepare_request(next_link=None): async def extract_data(pipeline_response): deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.Operation], deserialized.get("value", [])) + list_of_elem = _deserialize( + List[_models.Operation], + deserialized.get("value", []), + ) if cls: list_of_elem = cls(list_of_elem) # type: ignore return deserialized.get("nextLink") or None, AsyncList(list_of_elem) @@ -240,6 +245,7 @@ async def get( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -261,7 +267,7 @@ async def get( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.IspCustomerResource, response.json()) @@ -274,7 +280,7 @@ async def _create_or_update_initial( self, resource_group_name: str, customer_resource_name: str, - resource: Union[_models.IspCustomerResource, JSON, IO[bytes]], + resource: Union[_models.IspCustomerResource, _types.IspCustomerResource, IO[bytes]], **kwargs: Any ) -> AsyncIterator[bytes]: error_map: MutableMapping = { @@ -313,6 +319,7 @@ async def _create_or_update_initial( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -339,7 +346,7 @@ async def _create_or_update_initial( ) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -380,7 +387,7 @@ async def begin_create_or_update( self, resource_group_name: str, customer_resource_name: str, - resource: JSON, + resource: _types.IspCustomerResource, *, content_type: str = "application/json", **kwargs: Any @@ -393,7 +400,7 @@ async def begin_create_or_update( :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.connectedcache.types.IspCustomerResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -438,7 +445,7 @@ async def begin_create_or_update( self, resource_group_name: str, customer_resource_name: str, - resource: Union[_models.IspCustomerResource, JSON, IO[bytes]], + resource: Union[_models.IspCustomerResource, _types.IspCustomerResource, IO[bytes]], **kwargs: Any ) -> AsyncLROPoller[_models.IspCustomerResource]: """This api creates an ispCustomer with the specified create parameters. @@ -448,9 +455,10 @@ async def begin_create_or_update( :type resource_group_name: str :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str - :param resource: Resource create parameters. Is one of the following types: - IspCustomerResource, JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.connectedcache.models.IspCustomerResource or JSON or IO[bytes] + :param resource: Resource create parameters. Is either a IspCustomerResource type or a + IO[bytes] type. Required. + :type resource: ~azure.mgmt.connectedcache.models.IspCustomerResource or + ~azure.mgmt.connectedcache.types.IspCustomerResource or IO[bytes] :return: An instance of AsyncLROPoller that returns IspCustomerResource. The IspCustomerResource is compatible with MutableMapping :rtype: @@ -541,7 +549,7 @@ async def update( self, resource_group_name: str, customer_resource_name: str, - properties: JSON, + properties: _types.ConnectedCachePatchResource, *, content_type: str = "application/json", **kwargs: Any @@ -554,7 +562,7 @@ async def update( :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -595,7 +603,7 @@ async def update( self, resource_group_name: str, customer_resource_name: str, - properties: Union[_models.ConnectedCachePatchResource, JSON, IO[bytes]], + properties: Union[_models.ConnectedCachePatchResource, _types.ConnectedCachePatchResource, IO[bytes]], **kwargs: Any ) -> _models.IspCustomerResource: """This api updates an existing ispCustomer resource. @@ -605,10 +613,10 @@ async def update( :type resource_group_name: str :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str - :param properties: The resource properties to be updated. Is one of the following types: - ConnectedCachePatchResource, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or JSON or - IO[bytes] + :param properties: The resource properties to be updated. Is either a + ConnectedCachePatchResource type or a IO[bytes] type. Required. + :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or + ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource or IO[bytes] :return: IspCustomerResource. The IspCustomerResource is compatible with MutableMapping :rtype: ~azure.mgmt.connectedcache.models.IspCustomerResource :raises ~azure.core.exceptions.HttpResponseError: @@ -649,6 +657,7 @@ async def update( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -670,7 +679,7 @@ async def update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.IspCustomerResource, response.json()) @@ -708,6 +717,7 @@ async def _delete_initial( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -732,7 +742,7 @@ async def _delete_initial( response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -854,7 +864,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -867,7 +880,10 @@ def prepare_request(next_link=None): async def extract_data(pipeline_response): deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.IspCustomerResource], deserialized.get("value", [])) + list_of_elem = _deserialize( + List[_models.IspCustomerResource], + deserialized.get("value", []), + ) if cls: list_of_elem = cls(list_of_elem) # type: ignore return deserialized.get("nextLink") or None, AsyncList(list_of_elem) @@ -942,7 +958,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -955,7 +974,10 @@ def prepare_request(next_link=None): async def extract_data(pipeline_response): deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.IspCustomerResource], deserialized.get("value", [])) + list_of_elem = _deserialize( + List[_models.IspCustomerResource], + deserialized.get("value", []), + ) if cls: list_of_elem = cls(list_of_elem) # type: ignore return deserialized.get("nextLink") or None, AsyncList(list_of_elem) @@ -1043,6 +1065,7 @@ async def get( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1064,7 +1087,7 @@ async def get( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.IspCacheNodeResource, response.json()) @@ -1078,7 +1101,7 @@ async def _create_or_update_initial( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - resource: Union[_models.IspCacheNodeResource, JSON, IO[bytes]], + resource: Union[_models.IspCacheNodeResource, _types.IspCacheNodeResource, IO[bytes]], **kwargs: Any ) -> AsyncIterator[bytes]: error_map: MutableMapping = { @@ -1118,6 +1141,7 @@ async def _create_or_update_initial( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1144,7 +1168,7 @@ async def _create_or_update_initial( ) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -1189,7 +1213,7 @@ async def begin_create_or_update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - resource: JSON, + resource: _types.IspCacheNodeResource, *, content_type: str = "application/json", **kwargs: Any @@ -1204,7 +1228,7 @@ async def begin_create_or_update( :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.connectedcache.types.IspCacheNodeResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -1253,7 +1277,7 @@ async def begin_create_or_update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - resource: Union[_models.IspCacheNodeResource, JSON, IO[bytes]], + resource: Union[_models.IspCacheNodeResource, _types.IspCacheNodeResource, IO[bytes]], **kwargs: Any ) -> AsyncLROPoller[_models.IspCacheNodeResource]: """This api creates an ispCacheNode with the specified create parameters. @@ -1265,9 +1289,10 @@ async def begin_create_or_update( :type customer_resource_name: str :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str - :param resource: Resource create parameters. Is one of the following types: - IspCacheNodeResource, JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.connectedcache.models.IspCacheNodeResource or JSON or IO[bytes] + :param resource: Resource create parameters. Is either a IspCacheNodeResource type or a + IO[bytes] type. Required. + :type resource: ~azure.mgmt.connectedcache.models.IspCacheNodeResource or + ~azure.mgmt.connectedcache.types.IspCacheNodeResource or IO[bytes] :return: An instance of AsyncLROPoller that returns IspCacheNodeResource. The IspCacheNodeResource is compatible with MutableMapping :rtype: @@ -1363,7 +1388,7 @@ async def update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - properties: JSON, + properties: _types.ConnectedCachePatchResource, *, content_type: str = "application/json", **kwargs: Any @@ -1378,7 +1403,7 @@ async def update( :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -1423,7 +1448,7 @@ async def update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - properties: Union[_models.ConnectedCachePatchResource, JSON, IO[bytes]], + properties: Union[_models.ConnectedCachePatchResource, _types.ConnectedCachePatchResource, IO[bytes]], **kwargs: Any ) -> _models.IspCacheNodeResource: """This api updates an existing ispCacheNode resource. @@ -1435,10 +1460,10 @@ async def update( :type customer_resource_name: str :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str - :param properties: The resource properties to be updated. Is one of the following types: - ConnectedCachePatchResource, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or JSON or - IO[bytes] + :param properties: The resource properties to be updated. Is either a + ConnectedCachePatchResource type or a IO[bytes] type. Required. + :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or + ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource or IO[bytes] :return: IspCacheNodeResource. The IspCacheNodeResource is compatible with MutableMapping :rtype: ~azure.mgmt.connectedcache.models.IspCacheNodeResource :raises ~azure.core.exceptions.HttpResponseError: @@ -1480,6 +1505,7 @@ async def update( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1501,7 +1527,7 @@ async def update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.IspCacheNodeResource, response.json()) @@ -1540,6 +1566,7 @@ async def _delete_initial( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1564,7 +1591,7 @@ async def _delete_initial( response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -1692,7 +1719,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -1705,7 +1735,10 @@ def prepare_request(next_link=None): async def extract_data(pipeline_response): deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.IspCacheNodeResource], deserialized.get("value", [])) + list_of_elem = _deserialize( + List[_models.IspCacheNodeResource], + deserialized.get("value", []), + ) if cls: list_of_elem = cls(list_of_elem) # type: ignore return deserialized.get("nextLink") or None, AsyncList(list_of_elem) @@ -1776,6 +1809,7 @@ async def get_bgp_cidrs( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1797,7 +1831,7 @@ async def get_bgp_cidrs( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeBgpCidrDetails, response.json()) @@ -1851,6 +1885,7 @@ async def get_cache_node_install_details( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1872,7 +1907,7 @@ async def get_cache_node_install_details( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeInstallDetails, response.json()) @@ -1894,7 +1929,7 @@ async def get_cache_node_install_details( "accept", ] }, - api_versions_list=["2024-11-30-preview"], + api_versions_list=["2024-11-30-preview", "2026-06-01"], ) async def get_cache_node_auto_update_history( self, resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, **kwargs: Any @@ -1940,6 +1975,7 @@ async def get_cache_node_auto_update_history( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1961,7 +1997,7 @@ async def get_cache_node_auto_update_history( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeAutoUpdateHistory, response.json()) @@ -1983,7 +2019,7 @@ async def get_cache_node_auto_update_history( "accept", ] }, - api_versions_list=["2024-11-30-preview"], + api_versions_list=["2024-11-30-preview", "2026-06-01"], ) async def get_cache_node_mcc_issue_details_history( self, resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, **kwargs: Any @@ -2029,6 +2065,7 @@ async def get_cache_node_mcc_issue_details_history( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -2050,7 +2087,7 @@ async def get_cache_node_mcc_issue_details_history( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeIssueHistory, response.json()) @@ -2119,6 +2156,7 @@ async def get( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -2140,7 +2178,7 @@ async def get( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.EnterpriseMccCustomerResource, response.json()) @@ -2153,7 +2191,7 @@ async def _create_or_update_initial( self, resource_group_name: str, customer_resource_name: str, - resource: Union[_models.EnterpriseMccCustomerResource, JSON, IO[bytes]], + resource: Union[_models.EnterpriseMccCustomerResource, _types.EnterpriseMccCustomerResource, IO[bytes]], **kwargs: Any ) -> AsyncIterator[bytes]: error_map: MutableMapping = { @@ -2192,6 +2230,7 @@ async def _create_or_update_initial( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -2218,7 +2257,7 @@ async def _create_or_update_initial( ) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -2259,7 +2298,7 @@ async def begin_create_or_update( self, resource_group_name: str, customer_resource_name: str, - resource: JSON, + resource: _types.EnterpriseMccCustomerResource, *, content_type: str = "application/json", **kwargs: Any @@ -2272,7 +2311,7 @@ async def begin_create_or_update( :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.connectedcache.types.EnterpriseMccCustomerResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -2317,7 +2356,7 @@ async def begin_create_or_update( self, resource_group_name: str, customer_resource_name: str, - resource: Union[_models.EnterpriseMccCustomerResource, JSON, IO[bytes]], + resource: Union[_models.EnterpriseMccCustomerResource, _types.EnterpriseMccCustomerResource, IO[bytes]], **kwargs: Any ) -> AsyncLROPoller[_models.EnterpriseMccCustomerResource]: """This api creates an enterprise mcc customer with the specified create parameters. @@ -2327,10 +2366,10 @@ async def begin_create_or_update( :type resource_group_name: str :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str - :param resource: Resource create parameters. Is one of the following types: - EnterpriseMccCustomerResource, JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.connectedcache.models.EnterpriseMccCustomerResource or JSON or - IO[bytes] + :param resource: Resource create parameters. Is either a EnterpriseMccCustomerResource type or + a IO[bytes] type. Required. + :type resource: ~azure.mgmt.connectedcache.models.EnterpriseMccCustomerResource or + ~azure.mgmt.connectedcache.types.EnterpriseMccCustomerResource or IO[bytes] :return: An instance of AsyncLROPoller that returns EnterpriseMccCustomerResource. The EnterpriseMccCustomerResource is compatible with MutableMapping :rtype: @@ -2422,7 +2461,7 @@ async def update( self, resource_group_name: str, customer_resource_name: str, - properties: JSON, + properties: _types.ConnectedCachePatchResource, *, content_type: str = "application/json", **kwargs: Any @@ -2435,7 +2474,7 @@ async def update( :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -2478,7 +2517,7 @@ async def update( self, resource_group_name: str, customer_resource_name: str, - properties: Union[_models.ConnectedCachePatchResource, JSON, IO[bytes]], + properties: Union[_models.ConnectedCachePatchResource, _types.ConnectedCachePatchResource, IO[bytes]], **kwargs: Any ) -> _models.EnterpriseMccCustomerResource: """This api updates an existing enterprise mcc customer resource. @@ -2488,10 +2527,10 @@ async def update( :type resource_group_name: str :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str - :param properties: The resource properties to be updated. Is one of the following types: - ConnectedCachePatchResource, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or JSON or - IO[bytes] + :param properties: The resource properties to be updated. Is either a + ConnectedCachePatchResource type or a IO[bytes] type. Required. + :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or + ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource or IO[bytes] :return: EnterpriseMccCustomerResource. The EnterpriseMccCustomerResource is compatible with MutableMapping :rtype: ~azure.mgmt.connectedcache.models.EnterpriseMccCustomerResource @@ -2533,6 +2572,7 @@ async def update( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -2554,7 +2594,7 @@ async def update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.EnterpriseMccCustomerResource, response.json()) @@ -2592,6 +2632,7 @@ async def _delete_initial( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -2616,7 +2657,7 @@ async def _delete_initial( response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -2738,7 +2779,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -2751,7 +2795,10 @@ def prepare_request(next_link=None): async def extract_data(pipeline_response): deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.EnterpriseMccCustomerResource], deserialized.get("value", [])) + list_of_elem = _deserialize( + List[_models.EnterpriseMccCustomerResource], + deserialized.get("value", []), + ) if cls: list_of_elem = cls(list_of_elem) # type: ignore return deserialized.get("nextLink") or None, AsyncList(list_of_elem) @@ -2827,7 +2874,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -2840,7 +2890,10 @@ def prepare_request(next_link=None): async def extract_data(pipeline_response): deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.EnterpriseMccCustomerResource], deserialized.get("value", [])) + list_of_elem = _deserialize( + List[_models.EnterpriseMccCustomerResource], + deserialized.get("value", []), + ) if cls: list_of_elem = cls(list_of_elem) # type: ignore return deserialized.get("nextLink") or None, AsyncList(list_of_elem) @@ -2929,6 +2982,7 @@ async def get( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -2950,7 +3004,7 @@ async def get( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.EnterpriseMccCacheNodeResource, response.json()) @@ -2964,7 +3018,7 @@ async def _create_or_update_initial( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - resource: Union[_models.EnterpriseMccCacheNodeResource, JSON, IO[bytes]], + resource: Union[_models.EnterpriseMccCacheNodeResource, _types.EnterpriseMccCacheNodeResource, IO[bytes]], **kwargs: Any ) -> AsyncIterator[bytes]: error_map: MutableMapping = { @@ -3004,6 +3058,7 @@ async def _create_or_update_initial( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -3030,7 +3085,7 @@ async def _create_or_update_initial( ) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -3075,7 +3130,7 @@ async def begin_create_or_update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - resource: JSON, + resource: _types.EnterpriseMccCacheNodeResource, *, content_type: str = "application/json", **kwargs: Any @@ -3090,7 +3145,7 @@ async def begin_create_or_update( :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.connectedcache.types.EnterpriseMccCacheNodeResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -3139,7 +3194,7 @@ async def begin_create_or_update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - resource: Union[_models.EnterpriseMccCacheNodeResource, JSON, IO[bytes]], + resource: Union[_models.EnterpriseMccCacheNodeResource, _types.EnterpriseMccCacheNodeResource, IO[bytes]], **kwargs: Any ) -> AsyncLROPoller[_models.EnterpriseMccCacheNodeResource]: """This api creates an ispCacheNode with the specified create parameters. @@ -3151,10 +3206,10 @@ async def begin_create_or_update( :type customer_resource_name: str :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str - :param resource: Resource create parameters. Is one of the following types: - EnterpriseMccCacheNodeResource, JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.connectedcache.models.EnterpriseMccCacheNodeResource or JSON or - IO[bytes] + :param resource: Resource create parameters. Is either a EnterpriseMccCacheNodeResource type or + a IO[bytes] type. Required. + :type resource: ~azure.mgmt.connectedcache.models.EnterpriseMccCacheNodeResource or + ~azure.mgmt.connectedcache.types.EnterpriseMccCacheNodeResource or IO[bytes] :return: An instance of AsyncLROPoller that returns EnterpriseMccCacheNodeResource. The EnterpriseMccCacheNodeResource is compatible with MutableMapping :rtype: @@ -3251,7 +3306,7 @@ async def update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - properties: JSON, + properties: _types.ConnectedCachePatchResource, *, content_type: str = "application/json", **kwargs: Any @@ -3266,7 +3321,7 @@ async def update( :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -3313,7 +3368,7 @@ async def update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - properties: Union[_models.ConnectedCachePatchResource, JSON, IO[bytes]], + properties: Union[_models.ConnectedCachePatchResource, _types.ConnectedCachePatchResource, IO[bytes]], **kwargs: Any ) -> _models.EnterpriseMccCacheNodeResource: """This api updates an existing ispCacheNode resource. @@ -3325,10 +3380,10 @@ async def update( :type customer_resource_name: str :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str - :param properties: The resource properties to be updated. Is one of the following types: - ConnectedCachePatchResource, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or JSON or - IO[bytes] + :param properties: The resource properties to be updated. Is either a + ConnectedCachePatchResource type or a IO[bytes] type. Required. + :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or + ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource or IO[bytes] :return: EnterpriseMccCacheNodeResource. The EnterpriseMccCacheNodeResource is compatible with MutableMapping :rtype: ~azure.mgmt.connectedcache.models.EnterpriseMccCacheNodeResource @@ -3371,6 +3426,7 @@ async def update( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -3392,7 +3448,7 @@ async def update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.EnterpriseMccCacheNodeResource, response.json()) @@ -3431,6 +3487,7 @@ async def _delete_initial( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -3455,7 +3512,7 @@ async def _delete_initial( response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -3583,7 +3640,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -3596,7 +3656,10 @@ def prepare_request(next_link=None): async def extract_data(pipeline_response): deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.EnterpriseMccCacheNodeResource], deserialized.get("value", [])) + list_of_elem = _deserialize( + List[_models.EnterpriseMccCacheNodeResource], + deserialized.get("value", []), + ) if cls: list_of_elem = cls(list_of_elem) # type: ignore return deserialized.get("nextLink") or None, AsyncList(list_of_elem) @@ -3667,6 +3730,7 @@ async def get_cache_node_install_details( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -3688,7 +3752,7 @@ async def get_cache_node_install_details( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeInstallDetails, response.json()) @@ -3710,7 +3774,7 @@ async def get_cache_node_install_details( "accept", ] }, - api_versions_list=["2024-11-30-preview"], + api_versions_list=["2024-11-30-preview", "2026-06-01"], ) async def get_cache_node_auto_update_history( self, resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, **kwargs: Any @@ -3756,6 +3820,7 @@ async def get_cache_node_auto_update_history( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -3777,7 +3842,7 @@ async def get_cache_node_auto_update_history( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeAutoUpdateHistory, response.json()) @@ -3799,7 +3864,7 @@ async def get_cache_node_auto_update_history( "accept", ] }, - api_versions_list=["2024-11-30-preview"], + api_versions_list=["2024-11-30-preview", "2026-06-01"], ) async def get_cache_node_mcc_issue_details_history( self, resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, **kwargs: Any @@ -3845,6 +3910,7 @@ async def get_cache_node_mcc_issue_details_history( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -3866,7 +3932,7 @@ async def get_cache_node_mcc_issue_details_history( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeIssueHistory, response.json()) @@ -3888,7 +3954,7 @@ async def get_cache_node_mcc_issue_details_history( "accept", ] }, - api_versions_list=["2024-11-30-preview"], + api_versions_list=["2024-11-30-preview", "2026-06-01"], ) async def get_cache_node_tls_certificate_history( self, resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, **kwargs: Any @@ -3934,6 +4000,7 @@ async def get_cache_node_tls_certificate_history( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -3955,7 +4022,7 @@ async def get_cache_node_tls_certificate_history( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeTlsCertificateHistory, response.json()) diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/models/_enums.py b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/models/_enums.py index b2d7b7fe7db1..444e16d06fee 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/models/_enums.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/models/_enums.py @@ -23,33 +23,37 @@ class AutoUpdateRingType(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Auto update Ring type.""" PREVIEW = "Preview" - """customer selection of preview update install mcc on their physical vm""" + """customer selection of preview update install mcc on their physical vm.""" SLOW = "Slow" - """customer selection of slow update to install mcc on their physical vm""" + """customer selection of slow update to install mcc on their physical vm.""" FAST = "Fast" - """customer selection of fast / auto update to install mcc on their physical vm""" + """customer selection of fast / auto update to install mcc on their physical vm.""" + STABLE = "Stable" + """customer selection of stable update to install mcc on their physical vm.""" + BETA = "Beta" + """customer selection of beta update to install mcc on their physical vm.""" class BgpReviewStateEnum(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Cache node resource Bgp review state as integer.""" NOT_CONFIGURED = "NotConfigured" - """bgp not configured""" + """bgp not configured.""" IN_REVIEW = "InReview" - """bgp is in review state""" + """bgp is in review state.""" APPROVED = "Approved" - """bgp is in Approved state""" + """bgp is in Approved state.""" ATTENTION_REQUIRED = "AttentionRequired" - """bgp is setup need an attention for more troubleshoot""" + """bgp is setup need an attention for more troubleshoot.""" class ConfigurationState(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Cache node configuration setup state.""" CONFIGURED = "Configured" - """connected cache setup configured""" + """connected cache setup configured.""" NOT_CONFIGURED_IP = "NotConfigured_Ip" - """connected cache setup not configured""" + """connected cache setup not configured.""" class CreatedByType(str, Enum, metaclass=CaseInsensitiveEnumMeta): @@ -69,11 +73,11 @@ class CustomerTransitState(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Customer resource transit states.""" NO_TRANSIT = "NoTransit" - """do not have transit""" + """do not have transit.""" COMBINED_TRANSIT = "CombinedTransit" - """transit provider and have own subscribers""" + """transit provider and have own subscribers.""" TRANSIT_ONLY = "TransitOnly" - """pure transit provider or network service provider""" + """pure transit provider or network service provider.""" class Origin(str, Enum, metaclass=CaseInsensitiveEnumMeta): @@ -93,11 +97,11 @@ class OsType(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Operating System of the cache node.""" WINDOWS = "Windows" - """cache node installs on windows operating system""" + """cache node installs on windows operating system.""" LINUX = "Linux" - """cache node installs on Linux Operating system""" + """cache node installs on Linux Operating system.""" EFLOW = "Eflow" - """cache node installs on Azure Eflow""" + """cache node installs on Azure Eflow.""" class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): @@ -110,19 +114,19 @@ class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): CANCELED = "Canceled" """Resource creation was canceled.""" UNKNOWN = "Unknown" - """unknown state of the provisioning state""" + """unknown state of the provisioning state.""" ACCEPTED = "Accepted" - """Accepted state of the provisioning state during the Async Operations""" + """Accepted state of the provisioning state during the Async Operations.""" UPGRADING = "Upgrading" - """Upgrading state of the provisioning state""" + """Upgrading state of the provisioning state.""" DELETING = "Deleting" - """Deleting state of the provisioning state""" + """Deleting state of the provisioning state.""" class ProxyRequired(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Proxy details enum.""" NONE = "None" - """Proxy is not required in setup""" + """Proxy is not required in setup.""" REQUIRED = "Required" - """proxy is required in setup""" + """proxy is required in setup.""" diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/models/_models.py b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/models/_models.py index 7703513ea43c..53a415bb66a7 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/models/_models.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/models/_models.py @@ -90,6 +90,37 @@ class AdditionalCacheNodeProperties(_Model): :vartype creation_method: int :ivar tls_status: Cache node tls certificate status. :vartype tls_status: str + :ivar host_os_edition: Operating system edition of the cache node host machine. + :vartype host_os_edition: str + :ivar host_os_version: Operating system version of the cache node host machine. + :vartype host_os_version: str + :ivar host_os_build: Operating system build of the cache node host machine. + :vartype host_os_build: str + :ivar distro_os_edition_wsl: Operating system edition of the WSL Linux distribution used to run + the cache node on Windows host machines. + :vartype distro_os_edition_wsl: str + :ivar distro_os_version_wsl: Operating system version of the WSL Linux distribution used to run + the cache node on Windows host machines. + :vartype distro_os_version_wsl: str + :ivar distro_os_build_wsl: Operating system build of the WSL Linux distribution used to run the + cache node on Windows host machines. + :vartype distro_os_build_wsl: str + :ivar container_os_edition: Operating system edition of container used to run the cache node. + :vartype container_os_edition: str + :ivar container_os_version: Operating system version of the container used to run the cache + node. + :vartype container_os_version: str + :ivar container_os_build: Operating system build of the container used to run the cache node. + :vartype container_os_build: str + :ivar install_version_msix: Version of the Windows deployment application used to deploy the + cache node. + :vartype install_version_msix: str + :ivar install_version_script: Version of the installation scripts used to deploy the cache + node. + :vartype install_version_script: str + :ivar app_version_wsl: Version of the Windows Subsystem for Linux application version used to + run the cache node on the Windows host machine. + :vartype app_version_wsl: str :ivar optional_property1: Optional property #1 of Mcc response object. :vartype optional_property1: str :ivar optional_property2: Optional property #2 of Mcc response object. @@ -197,6 +228,34 @@ class AdditionalCacheNodeProperties(_Model): """Resource creation method of mcc cache node resource, cli or portal.""" tls_status: Optional[str] = rest_field(name="tlsStatus", visibility=["read"]) """Cache node tls certificate status.""" + host_os_edition: Optional[str] = rest_field(name="hostOsEdition", visibility=["read"]) + """Operating system edition of the cache node host machine.""" + host_os_version: Optional[str] = rest_field(name="hostOsVersion", visibility=["read"]) + """Operating system version of the cache node host machine.""" + host_os_build: Optional[str] = rest_field(name="hostOsBuild", visibility=["read"]) + """Operating system build of the cache node host machine.""" + distro_os_edition_wsl: Optional[str] = rest_field(name="distroOsEditionWsl", visibility=["read"]) + """Operating system edition of the WSL Linux distribution used to run the cache node on Windows + host machines.""" + distro_os_version_wsl: Optional[str] = rest_field(name="distroOsVersionWsl", visibility=["read"]) + """Operating system version of the WSL Linux distribution used to run the cache node on Windows + host machines.""" + distro_os_build_wsl: Optional[str] = rest_field(name="distroOsBuildWsl", visibility=["read"]) + """Operating system build of the WSL Linux distribution used to run the cache node on Windows host + machines.""" + container_os_edition: Optional[str] = rest_field(name="containerOsEdition", visibility=["read"]) + """Operating system edition of container used to run the cache node.""" + container_os_version: Optional[str] = rest_field(name="containerOsVersion", visibility=["read"]) + """Operating system version of the container used to run the cache node.""" + container_os_build: Optional[str] = rest_field(name="containerOsBuild", visibility=["read"]) + """Operating system build of the container used to run the cache node.""" + install_version_msix: Optional[str] = rest_field(name="installVersionMsix", visibility=["read"]) + """Version of the Windows deployment application used to deploy the cache node.""" + install_version_script: Optional[str] = rest_field(name="installVersionScript", visibility=["read"]) + """Version of the installation scripts used to deploy the cache node.""" + app_version_wsl: Optional[str] = rest_field(name="appVersionWsl", visibility=["read"]) + """Version of the Windows Subsystem for Linux application version used to run the cache node on + the Windows host machine.""" optional_property1: Optional[str] = rest_field( name="optionalProperty1", visibility=["read", "create", "update", "delete", "query"] ) @@ -608,6 +667,8 @@ class CacheNodeEntity(_Model): :vartype cidr_csv: list[str] :ivar cidr_csv_last_update_time: Cache node resource last Cidr Csv update timestamp. :vartype cidr_csv_last_update_time: ~datetime.datetime + :ivar bgp_network_interface: Cache node resource Bgp network interface. + :vartype bgp_network_interface: str :ivar bgp_cidr_csv_last_update_time: Cache node resource last Bgp Cidr Csv update timestamp. :vartype bgp_cidr_csv_last_update_time: ~datetime.datetime :ivar bgp_last_reported_time: Cache node resource last Bgp report timestamp. @@ -663,8 +724,9 @@ class CacheNodeEntity(_Model): :ivar fully_qualified_domain_name: FQDN(fully qualified domain name) value of the mcc cache node. :vartype fully_qualified_domain_name: str - :ivar auto_update_ring_type: Auto Update Ring Type which is slow or fast etc. Known values are: - "Preview", "Slow", and "Fast". + :ivar auto_update_ring_type: Auto Update Ring Type which is stable or beta as new values. slow + or fast are legacy from version 2026-06-01. Known values are: "Preview", "Slow", "Fast", + "Stable", and "Beta". :vartype auto_update_ring_type: str or ~azure.mgmt.connectedcache.models.AutoUpdateRingType :ivar auto_update_requested_week: Customer requested week of month for mcc install of auto update cycle. 0 is default no selection. 1-5 are valid weeks of month, 1 is first week, 2 is @@ -676,6 +738,19 @@ class CacheNodeEntity(_Model): :ivar auto_update_requested_time: Customer requested time of the day for mcc install of auto update cycle, should be hh:mm. :vartype auto_update_requested_time: str + :ivar open_firewall_port80: Cache node port firewall rule creation opt-in for port 80 property. + :vartype open_firewall_port80: bool + :ivar open_firewall_port443: Cache node port firewall rule creation opt-in for port 443 + property. + :vartype open_firewall_port443: bool + :ivar open_firewall_port5000: Cache node port firewall rule creation opt-in for port 5000 + property. + :vartype open_firewall_port5000: bool + :ivar open_firewall_port5001: Cache node port firewall rule creation opt-in for port 5001 + property. + :vartype open_firewall_port5001: bool + :ivar runtime_account_type: Connected Cache runtime account type. + :vartype runtime_account_type: str """ fully_qualified_resource_id: Optional[str] = rest_field( @@ -752,6 +827,10 @@ class CacheNodeEntity(_Model): name="cidrCsvLastUpdateTime", visibility=["read"], format="rfc3339" ) """Cache node resource last Cidr Csv update timestamp.""" + bgp_network_interface: Optional[str] = rest_field( + name="bgpNetworkInterface", visibility=["read", "create", "update", "delete", "query"] + ) + """Cache node resource Bgp network interface.""" bgp_cidr_csv_last_update_time: Optional[datetime.datetime] = rest_field( name="bgpCidrCsvLastUpdateTime", visibility=["read"], format="rfc3339" ) @@ -822,8 +901,9 @@ class CacheNodeEntity(_Model): auto_update_ring_type: Optional[Union[str, "_models.AutoUpdateRingType"]] = rest_field( name="autoUpdateRingType", visibility=["read", "create", "update", "delete", "query"] ) - """Auto Update Ring Type which is slow or fast etc. Known values are: \"Preview\", \"Slow\", and - \"Fast\".""" + """Auto Update Ring Type which is stable or beta as new values. slow or fast are legacy from + version 2026-06-01. Known values are: \"Preview\", \"Slow\", \"Fast\", \"Stable\", and + \"Beta\".""" auto_update_requested_week: Optional[int] = rest_field( name="autoUpdateRequestedWeek", visibility=["read", "create", "update", "delete", "query"] ) @@ -838,6 +918,26 @@ class CacheNodeEntity(_Model): name="autoUpdateRequestedTime", visibility=["read", "create", "update", "delete", "query"] ) """Customer requested time of the day for mcc install of auto update cycle, should be hh:mm.""" + open_firewall_port80: Optional[bool] = rest_field( + name="openFirewallPort80", visibility=["read", "create", "update", "delete", "query"] + ) + """Cache node port firewall rule creation opt-in for port 80 property.""" + open_firewall_port443: Optional[bool] = rest_field( + name="openFirewallPort443", visibility=["read", "create", "update", "delete", "query"] + ) + """Cache node port firewall rule creation opt-in for port 443 property.""" + open_firewall_port5000: Optional[bool] = rest_field( + name="openFirewallPort5000", visibility=["read", "create", "update", "delete", "query"] + ) + """Cache node port firewall rule creation opt-in for port 5000 property.""" + open_firewall_port5001: Optional[bool] = rest_field( + name="openFirewallPort5001", visibility=["read", "create", "update", "delete", "query"] + ) + """Cache node port firewall rule creation opt-in for port 5001 property.""" + runtime_account_type: Optional[str] = rest_field( + name="runtimeAccountType", visibility=["read", "create", "update", "delete", "query"] + ) + """Connected Cache runtime account type.""" @overload def __init__( # pylint: disable=too-many-locals @@ -854,6 +954,7 @@ def __init__( # pylint: disable=too-many-locals max_allowable_egress_in_mbps: Optional[int] = None, is_enterprise_managed: Optional[bool] = None, cidr_csv: Optional[list[str]] = None, + bgp_network_interface: Optional[str] = None, should_migrate: Optional[bool] = None, cidr_selection_type: Optional[int] = None, fully_qualified_domain_name: Optional[str] = None, @@ -861,6 +962,11 @@ def __init__( # pylint: disable=too-many-locals auto_update_requested_week: Optional[int] = None, auto_update_requested_day: Optional[int] = None, auto_update_requested_time: Optional[str] = None, + open_firewall_port80: Optional[bool] = None, + open_firewall_port443: Optional[bool] = None, + open_firewall_port5000: Optional[bool] = None, + open_firewall_port5001: Optional[bool] = None, + runtime_account_type: Optional[str] = None, ) -> None: ... @overload @@ -1931,6 +2037,8 @@ class MccCacheNodeTlsCertificate(_Model): :vartype action_required: str :ivar certificate_file_name: Mcc cache node Tls certificate file name. :vartype certificate_file_name: str + :ivar cert_type: Mcc cache node Tls certificate Type. + :vartype cert_type: str :ivar thumbprint: Mcc cache node Tls certificate thumbprint. :vartype thumbprint: str :ivar expiry_date: Mcc cache node Tls certificate expiry date. @@ -1947,6 +2055,8 @@ class MccCacheNodeTlsCertificate(_Model): """Mcc cache node Tls certificate status.""" certificate_file_name: Optional[str] = rest_field(name="certificateFileName", visibility=["read"]) """Mcc cache node Tls certificate file name.""" + cert_type: Optional[str] = rest_field(name="certType", visibility=["read"]) + """Mcc cache node Tls certificate Type.""" thumbprint: Optional[str] = rest_field(visibility=["read"]) """Mcc cache node Tls certificate thumbprint.""" expiry_date: Optional[datetime.datetime] = rest_field(name="expiryDate", visibility=["read"], format="rfc3339") @@ -2138,7 +2248,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: class OperationDisplay(_Model): - """Localized display information for and operation. + """Localized display information for an operation. :ivar provider: The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft Compute". diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/operations/_operations.py b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/operations/_operations.py index d4e5c5c6b39e..1ec1d1174a9e 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/operations/_operations.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/operations/_operations.py @@ -32,7 +32,7 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from azure.mgmt.core.polling.arm_polling import ARMPolling -from .. import models as _models +from .. import models as _models, types as _types from .._configuration import ConnectedCacheMgmtClientConfiguration from .._utils.model_base import SdkJSONEncoder, _deserialize, _failsafe_deserialize from .._utils.serialization import Deserializer, Serializer @@ -40,7 +40,6 @@ T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, dict[str, Any]], Any]] -JSON = MutableMapping[str, Any] List = list _SERIALIZER = Serializer() @@ -51,7 +50,7 @@ def build_operations_list_request(**kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -72,7 +71,7 @@ def build_isp_customers_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -101,7 +100,7 @@ def build_isp_customers_create_or_update_request( # pylint: disable=name-too-lo _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -132,7 +131,7 @@ def build_isp_customers_update_request( _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -161,7 +160,7 @@ def build_isp_customers_delete_request( ) -> HttpRequest: _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) # Construct URL _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ConnectedCache/ispCustomers/{customerResourceName}" path_format_arguments = { @@ -184,7 +183,7 @@ def build_isp_customers_list_by_resource_group_request( # pylint: disable=name- _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -211,7 +210,7 @@ def build_isp_customers_list_by_subscription_request( # pylint: disable=name-to _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -241,7 +240,7 @@ def build_isp_cache_nodes_operations_get_request( # pylint: disable=name-too-lo _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -275,7 +274,7 @@ def build_isp_cache_nodes_operations_create_or_update_request( # pylint: disabl _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -311,7 +310,7 @@ def build_isp_cache_nodes_operations_update_request( # pylint: disable=name-too _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -345,7 +344,7 @@ def build_isp_cache_nodes_operations_delete_request( # pylint: disable=name-too ) -> HttpRequest: _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) # Construct URL _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ConnectedCache/ispCustomers/{customerResourceName}/ispCacheNodes/{cacheNodeResourceName}" path_format_arguments = { @@ -369,7 +368,7 @@ def build_isp_cache_nodes_operations_list_by_isp_customer_resource_request( # p _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -401,7 +400,7 @@ def build_isp_cache_nodes_operations_get_bgp_cidrs_request( # pylint: disable=n _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -434,7 +433,7 @@ def build_isp_cache_nodes_operations_get_cache_node_install_details_request( # _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -467,7 +466,7 @@ def build_isp_cache_nodes_operations_get_cache_node_auto_update_history_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -500,7 +499,7 @@ def build_isp_cache_nodes_operations_get_cache_node_mcc_issue_details_history_re _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -529,7 +528,7 @@ def build_enterprise_mcc_customers_get_request( # pylint: disable=name-too-long _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -558,7 +557,7 @@ def build_enterprise_mcc_customers_create_or_update_request( # pylint: disable= _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -589,7 +588,7 @@ def build_enterprise_mcc_customers_update_request( # pylint: disable=name-too-l _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -618,7 +617,7 @@ def build_enterprise_mcc_customers_delete_request( # pylint: disable=name-too-l ) -> HttpRequest: _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) # Construct URL _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ConnectedCache/enterpriseMccCustomers/{customerResourceName}" path_format_arguments = { @@ -641,7 +640,7 @@ def build_enterprise_mcc_customers_list_by_resource_group_request( # pylint: di _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -668,7 +667,7 @@ def build_enterprise_mcc_customers_list_by_subscription_request( # pylint: disa _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -698,7 +697,7 @@ def build_enterprise_mcc_cache_nodes_operations_get_request( # pylint: disable= _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -732,7 +731,7 @@ def build_enterprise_mcc_cache_nodes_operations_create_or_update_request( # pyl _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -768,7 +767,7 @@ def build_enterprise_mcc_cache_nodes_operations_update_request( # pylint: disab _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -802,7 +801,7 @@ def build_enterprise_mcc_cache_nodes_operations_delete_request( # pylint: disab ) -> HttpRequest: _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) # Construct URL _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ConnectedCache/enterpriseMccCustomers/{customerResourceName}/enterpriseMccCacheNodes/{cacheNodeResourceName}" path_format_arguments = { @@ -826,7 +825,7 @@ def build_enterprise_mcc_cache_nodes_operations_list_by_enterprise_mcc_customer_ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -858,7 +857,7 @@ def build_enterprise_mcc_cache_nodes_operations_get_cache_node_install_details_r _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -891,7 +890,7 @@ def build_enterprise_mcc_cache_nodes_operations_get_cache_node_auto_update_histo _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -924,7 +923,7 @@ def build_enterprise_mcc_cache_nodes_operations_get_cache_node_mcc_issue_details _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -957,7 +956,7 @@ def build_enterprise_mcc_cache_nodes_operations_get_cache_node_tls_certificate_h _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-30-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -1044,7 +1043,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -1057,7 +1059,10 @@ def prepare_request(next_link=None): def extract_data(pipeline_response): deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.Operation], deserialized.get("value", [])) + list_of_elem = _deserialize( + List[_models.Operation], + deserialized.get("value", []), + ) if cls: list_of_elem = cls(list_of_elem) # type: ignore return deserialized.get("nextLink") or None, iter(list_of_elem) @@ -1140,6 +1145,7 @@ def get(self, resource_group_name: str, customer_resource_name: str, **kwargs: A } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1161,7 +1167,7 @@ def get(self, resource_group_name: str, customer_resource_name: str, **kwargs: A raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.IspCustomerResource, response.json()) @@ -1174,7 +1180,7 @@ def _create_or_update_initial( self, resource_group_name: str, customer_resource_name: str, - resource: Union[_models.IspCustomerResource, JSON, IO[bytes]], + resource: Union[_models.IspCustomerResource, _types.IspCustomerResource, IO[bytes]], **kwargs: Any ) -> Iterator[bytes]: error_map: MutableMapping = { @@ -1213,6 +1219,7 @@ def _create_or_update_initial( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1239,7 +1246,7 @@ def _create_or_update_initial( ) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -1279,7 +1286,7 @@ def begin_create_or_update( self, resource_group_name: str, customer_resource_name: str, - resource: JSON, + resource: _types.IspCustomerResource, *, content_type: str = "application/json", **kwargs: Any @@ -1292,7 +1299,7 @@ def begin_create_or_update( :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.connectedcache.types.IspCustomerResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -1335,7 +1342,7 @@ def begin_create_or_update( self, resource_group_name: str, customer_resource_name: str, - resource: Union[_models.IspCustomerResource, JSON, IO[bytes]], + resource: Union[_models.IspCustomerResource, _types.IspCustomerResource, IO[bytes]], **kwargs: Any ) -> LROPoller[_models.IspCustomerResource]: """This api creates an ispCustomer with the specified create parameters. @@ -1345,9 +1352,10 @@ def begin_create_or_update( :type resource_group_name: str :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str - :param resource: Resource create parameters. Is one of the following types: - IspCustomerResource, JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.connectedcache.models.IspCustomerResource or JSON or IO[bytes] + :param resource: Resource create parameters. Is either a IspCustomerResource type or a + IO[bytes] type. Required. + :type resource: ~azure.mgmt.connectedcache.models.IspCustomerResource or + ~azure.mgmt.connectedcache.types.IspCustomerResource or IO[bytes] :return: An instance of LROPoller that returns IspCustomerResource. The IspCustomerResource is compatible with MutableMapping :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.connectedcache.models.IspCustomerResource] @@ -1437,7 +1445,7 @@ def update( self, resource_group_name: str, customer_resource_name: str, - properties: JSON, + properties: _types.ConnectedCachePatchResource, *, content_type: str = "application/json", **kwargs: Any @@ -1450,7 +1458,7 @@ def update( :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -1491,7 +1499,7 @@ def update( self, resource_group_name: str, customer_resource_name: str, - properties: Union[_models.ConnectedCachePatchResource, JSON, IO[bytes]], + properties: Union[_models.ConnectedCachePatchResource, _types.ConnectedCachePatchResource, IO[bytes]], **kwargs: Any ) -> _models.IspCustomerResource: """This api updates an existing ispCustomer resource. @@ -1501,10 +1509,10 @@ def update( :type resource_group_name: str :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str - :param properties: The resource properties to be updated. Is one of the following types: - ConnectedCachePatchResource, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or JSON or - IO[bytes] + :param properties: The resource properties to be updated. Is either a + ConnectedCachePatchResource type or a IO[bytes] type. Required. + :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or + ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource or IO[bytes] :return: IspCustomerResource. The IspCustomerResource is compatible with MutableMapping :rtype: ~azure.mgmt.connectedcache.models.IspCustomerResource :raises ~azure.core.exceptions.HttpResponseError: @@ -1545,6 +1553,7 @@ def update( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1566,7 +1575,7 @@ def update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.IspCustomerResource, response.json()) @@ -1602,6 +1611,7 @@ def _delete_initial(self, resource_group_name: str, customer_resource_name: str, } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1626,7 +1636,7 @@ def _delete_initial(self, resource_group_name: str, customer_resource_name: str, response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -1745,7 +1755,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -1758,7 +1771,10 @@ def prepare_request(next_link=None): def extract_data(pipeline_response): deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.IspCustomerResource], deserialized.get("value", [])) + list_of_elem = _deserialize( + List[_models.IspCustomerResource], + deserialized.get("value", []), + ) if cls: list_of_elem = cls(list_of_elem) # type: ignore return deserialized.get("nextLink") or None, iter(list_of_elem) @@ -1832,7 +1848,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -1845,7 +1864,10 @@ def prepare_request(next_link=None): def extract_data(pipeline_response): deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.IspCustomerResource], deserialized.get("value", [])) + list_of_elem = _deserialize( + List[_models.IspCustomerResource], + deserialized.get("value", []), + ) if cls: list_of_elem = cls(list_of_elem) # type: ignore return deserialized.get("nextLink") or None, iter(list_of_elem) @@ -1933,6 +1955,7 @@ def get( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -1954,7 +1977,7 @@ def get( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.IspCacheNodeResource, response.json()) @@ -1968,7 +1991,7 @@ def _create_or_update_initial( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - resource: Union[_models.IspCacheNodeResource, JSON, IO[bytes]], + resource: Union[_models.IspCacheNodeResource, _types.IspCacheNodeResource, IO[bytes]], **kwargs: Any ) -> Iterator[bytes]: error_map: MutableMapping = { @@ -2008,6 +2031,7 @@ def _create_or_update_initial( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -2034,7 +2058,7 @@ def _create_or_update_initial( ) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -2078,7 +2102,7 @@ def begin_create_or_update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - resource: JSON, + resource: _types.IspCacheNodeResource, *, content_type: str = "application/json", **kwargs: Any @@ -2093,7 +2117,7 @@ def begin_create_or_update( :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.connectedcache.types.IspCacheNodeResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -2140,7 +2164,7 @@ def begin_create_or_update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - resource: Union[_models.IspCacheNodeResource, JSON, IO[bytes]], + resource: Union[_models.IspCacheNodeResource, _types.IspCacheNodeResource, IO[bytes]], **kwargs: Any ) -> LROPoller[_models.IspCacheNodeResource]: """This api creates an ispCacheNode with the specified create parameters. @@ -2152,9 +2176,10 @@ def begin_create_or_update( :type customer_resource_name: str :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str - :param resource: Resource create parameters. Is one of the following types: - IspCacheNodeResource, JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.connectedcache.models.IspCacheNodeResource or JSON or IO[bytes] + :param resource: Resource create parameters. Is either a IspCacheNodeResource type or a + IO[bytes] type. Required. + :type resource: ~azure.mgmt.connectedcache.models.IspCacheNodeResource or + ~azure.mgmt.connectedcache.types.IspCacheNodeResource or IO[bytes] :return: An instance of LROPoller that returns IspCacheNodeResource. The IspCacheNodeResource is compatible with MutableMapping :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.connectedcache.models.IspCacheNodeResource] @@ -2249,7 +2274,7 @@ def update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - properties: JSON, + properties: _types.ConnectedCachePatchResource, *, content_type: str = "application/json", **kwargs: Any @@ -2264,7 +2289,7 @@ def update( :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -2309,7 +2334,7 @@ def update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - properties: Union[_models.ConnectedCachePatchResource, JSON, IO[bytes]], + properties: Union[_models.ConnectedCachePatchResource, _types.ConnectedCachePatchResource, IO[bytes]], **kwargs: Any ) -> _models.IspCacheNodeResource: """This api updates an existing ispCacheNode resource. @@ -2321,10 +2346,10 @@ def update( :type customer_resource_name: str :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str - :param properties: The resource properties to be updated. Is one of the following types: - ConnectedCachePatchResource, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or JSON or - IO[bytes] + :param properties: The resource properties to be updated. Is either a + ConnectedCachePatchResource type or a IO[bytes] type. Required. + :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or + ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource or IO[bytes] :return: IspCacheNodeResource. The IspCacheNodeResource is compatible with MutableMapping :rtype: ~azure.mgmt.connectedcache.models.IspCacheNodeResource :raises ~azure.core.exceptions.HttpResponseError: @@ -2366,6 +2391,7 @@ def update( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -2387,7 +2413,7 @@ def update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.IspCacheNodeResource, response.json()) @@ -2426,6 +2452,7 @@ def _delete_initial( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -2450,7 +2477,7 @@ def _delete_initial( response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -2577,7 +2604,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -2590,7 +2620,10 @@ def prepare_request(next_link=None): def extract_data(pipeline_response): deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.IspCacheNodeResource], deserialized.get("value", [])) + list_of_elem = _deserialize( + List[_models.IspCacheNodeResource], + deserialized.get("value", []), + ) if cls: list_of_elem = cls(list_of_elem) # type: ignore return deserialized.get("nextLink") or None, iter(list_of_elem) @@ -2661,6 +2694,7 @@ def get_bgp_cidrs( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -2682,7 +2716,7 @@ def get_bgp_cidrs( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeBgpCidrDetails, response.json()) @@ -2736,6 +2770,7 @@ def get_cache_node_install_details( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -2757,7 +2792,7 @@ def get_cache_node_install_details( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeInstallDetails, response.json()) @@ -2779,7 +2814,7 @@ def get_cache_node_install_details( "accept", ] }, - api_versions_list=["2024-11-30-preview"], + api_versions_list=["2024-11-30-preview", "2026-06-01"], ) def get_cache_node_auto_update_history( self, resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, **kwargs: Any @@ -2825,6 +2860,7 @@ def get_cache_node_auto_update_history( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -2846,7 +2882,7 @@ def get_cache_node_auto_update_history( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeAutoUpdateHistory, response.json()) @@ -2868,7 +2904,7 @@ def get_cache_node_auto_update_history( "accept", ] }, - api_versions_list=["2024-11-30-preview"], + api_versions_list=["2024-11-30-preview", "2026-06-01"], ) def get_cache_node_mcc_issue_details_history( self, resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, **kwargs: Any @@ -2914,6 +2950,7 @@ def get_cache_node_mcc_issue_details_history( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -2935,7 +2972,7 @@ def get_cache_node_mcc_issue_details_history( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeIssueHistory, response.json()) @@ -3004,6 +3041,7 @@ def get( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -3025,7 +3063,7 @@ def get( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.EnterpriseMccCustomerResource, response.json()) @@ -3038,7 +3076,7 @@ def _create_or_update_initial( self, resource_group_name: str, customer_resource_name: str, - resource: Union[_models.EnterpriseMccCustomerResource, JSON, IO[bytes]], + resource: Union[_models.EnterpriseMccCustomerResource, _types.EnterpriseMccCustomerResource, IO[bytes]], **kwargs: Any ) -> Iterator[bytes]: error_map: MutableMapping = { @@ -3077,6 +3115,7 @@ def _create_or_update_initial( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -3103,7 +3142,7 @@ def _create_or_update_initial( ) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -3144,7 +3183,7 @@ def begin_create_or_update( self, resource_group_name: str, customer_resource_name: str, - resource: JSON, + resource: _types.EnterpriseMccCustomerResource, *, content_type: str = "application/json", **kwargs: Any @@ -3157,7 +3196,7 @@ def begin_create_or_update( :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.connectedcache.types.EnterpriseMccCustomerResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -3202,7 +3241,7 @@ def begin_create_or_update( self, resource_group_name: str, customer_resource_name: str, - resource: Union[_models.EnterpriseMccCustomerResource, JSON, IO[bytes]], + resource: Union[_models.EnterpriseMccCustomerResource, _types.EnterpriseMccCustomerResource, IO[bytes]], **kwargs: Any ) -> LROPoller[_models.EnterpriseMccCustomerResource]: """This api creates an enterprise mcc customer with the specified create parameters. @@ -3212,10 +3251,10 @@ def begin_create_or_update( :type resource_group_name: str :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str - :param resource: Resource create parameters. Is one of the following types: - EnterpriseMccCustomerResource, JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.connectedcache.models.EnterpriseMccCustomerResource or JSON or - IO[bytes] + :param resource: Resource create parameters. Is either a EnterpriseMccCustomerResource type or + a IO[bytes] type. Required. + :type resource: ~azure.mgmt.connectedcache.models.EnterpriseMccCustomerResource or + ~azure.mgmt.connectedcache.types.EnterpriseMccCustomerResource or IO[bytes] :return: An instance of LROPoller that returns EnterpriseMccCustomerResource. The EnterpriseMccCustomerResource is compatible with MutableMapping :rtype: @@ -3307,7 +3346,7 @@ def update( self, resource_group_name: str, customer_resource_name: str, - properties: JSON, + properties: _types.ConnectedCachePatchResource, *, content_type: str = "application/json", **kwargs: Any @@ -3320,7 +3359,7 @@ def update( :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -3363,7 +3402,7 @@ def update( self, resource_group_name: str, customer_resource_name: str, - properties: Union[_models.ConnectedCachePatchResource, JSON, IO[bytes]], + properties: Union[_models.ConnectedCachePatchResource, _types.ConnectedCachePatchResource, IO[bytes]], **kwargs: Any ) -> _models.EnterpriseMccCustomerResource: """This api updates an existing enterprise mcc customer resource. @@ -3373,10 +3412,10 @@ def update( :type resource_group_name: str :param customer_resource_name: Name of the Customer resource. Required. :type customer_resource_name: str - :param properties: The resource properties to be updated. Is one of the following types: - ConnectedCachePatchResource, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or JSON or - IO[bytes] + :param properties: The resource properties to be updated. Is either a + ConnectedCachePatchResource type or a IO[bytes] type. Required. + :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or + ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource or IO[bytes] :return: EnterpriseMccCustomerResource. The EnterpriseMccCustomerResource is compatible with MutableMapping :rtype: ~azure.mgmt.connectedcache.models.EnterpriseMccCustomerResource @@ -3418,6 +3457,7 @@ def update( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -3439,7 +3479,7 @@ def update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.EnterpriseMccCustomerResource, response.json()) @@ -3475,6 +3515,7 @@ def _delete_initial(self, resource_group_name: str, customer_resource_name: str, } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -3499,7 +3540,7 @@ def _delete_initial(self, resource_group_name: str, customer_resource_name: str, response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -3619,7 +3660,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -3632,7 +3676,10 @@ def prepare_request(next_link=None): def extract_data(pipeline_response): deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.EnterpriseMccCustomerResource], deserialized.get("value", [])) + list_of_elem = _deserialize( + List[_models.EnterpriseMccCustomerResource], + deserialized.get("value", []), + ) if cls: list_of_elem = cls(list_of_elem) # type: ignore return deserialized.get("nextLink") or None, iter(list_of_elem) @@ -3708,7 +3755,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -3721,7 +3771,10 @@ def prepare_request(next_link=None): def extract_data(pipeline_response): deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.EnterpriseMccCustomerResource], deserialized.get("value", [])) + list_of_elem = _deserialize( + List[_models.EnterpriseMccCustomerResource], + deserialized.get("value", []), + ) if cls: list_of_elem = cls(list_of_elem) # type: ignore return deserialized.get("nextLink") or None, iter(list_of_elem) @@ -3810,6 +3863,7 @@ def get( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -3831,7 +3885,7 @@ def get( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.EnterpriseMccCacheNodeResource, response.json()) @@ -3845,7 +3899,7 @@ def _create_or_update_initial( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - resource: Union[_models.EnterpriseMccCacheNodeResource, JSON, IO[bytes]], + resource: Union[_models.EnterpriseMccCacheNodeResource, _types.EnterpriseMccCacheNodeResource, IO[bytes]], **kwargs: Any ) -> Iterator[bytes]: error_map: MutableMapping = { @@ -3885,6 +3939,7 @@ def _create_or_update_initial( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -3911,7 +3966,7 @@ def _create_or_update_initial( ) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -3956,7 +4011,7 @@ def begin_create_or_update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - resource: JSON, + resource: _types.EnterpriseMccCacheNodeResource, *, content_type: str = "application/json", **kwargs: Any @@ -3971,7 +4026,7 @@ def begin_create_or_update( :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.connectedcache.types.EnterpriseMccCacheNodeResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -4020,7 +4075,7 @@ def begin_create_or_update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - resource: Union[_models.EnterpriseMccCacheNodeResource, JSON, IO[bytes]], + resource: Union[_models.EnterpriseMccCacheNodeResource, _types.EnterpriseMccCacheNodeResource, IO[bytes]], **kwargs: Any ) -> LROPoller[_models.EnterpriseMccCacheNodeResource]: """This api creates an ispCacheNode with the specified create parameters. @@ -4032,10 +4087,10 @@ def begin_create_or_update( :type customer_resource_name: str :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str - :param resource: Resource create parameters. Is one of the following types: - EnterpriseMccCacheNodeResource, JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.connectedcache.models.EnterpriseMccCacheNodeResource or JSON or - IO[bytes] + :param resource: Resource create parameters. Is either a EnterpriseMccCacheNodeResource type or + a IO[bytes] type. Required. + :type resource: ~azure.mgmt.connectedcache.models.EnterpriseMccCacheNodeResource or + ~azure.mgmt.connectedcache.types.EnterpriseMccCacheNodeResource or IO[bytes] :return: An instance of LROPoller that returns EnterpriseMccCacheNodeResource. The EnterpriseMccCacheNodeResource is compatible with MutableMapping :rtype: @@ -4132,7 +4187,7 @@ def update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - properties: JSON, + properties: _types.ConnectedCachePatchResource, *, content_type: str = "application/json", **kwargs: Any @@ -4147,7 +4202,7 @@ def update( :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -4194,7 +4249,7 @@ def update( resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, - properties: Union[_models.ConnectedCachePatchResource, JSON, IO[bytes]], + properties: Union[_models.ConnectedCachePatchResource, _types.ConnectedCachePatchResource, IO[bytes]], **kwargs: Any ) -> _models.EnterpriseMccCacheNodeResource: """This api updates an existing ispCacheNode resource. @@ -4206,10 +4261,10 @@ def update( :type customer_resource_name: str :param cache_node_resource_name: Name of the ConnectedCache resource. Required. :type cache_node_resource_name: str - :param properties: The resource properties to be updated. Is one of the following types: - ConnectedCachePatchResource, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or JSON or - IO[bytes] + :param properties: The resource properties to be updated. Is either a + ConnectedCachePatchResource type or a IO[bytes] type. Required. + :type properties: ~azure.mgmt.connectedcache.models.ConnectedCachePatchResource or + ~azure.mgmt.connectedcache.types.ConnectedCachePatchResource or IO[bytes] :return: EnterpriseMccCacheNodeResource. The EnterpriseMccCacheNodeResource is compatible with MutableMapping :rtype: ~azure.mgmt.connectedcache.models.EnterpriseMccCacheNodeResource @@ -4252,6 +4307,7 @@ def update( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -4273,7 +4329,7 @@ def update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.EnterpriseMccCacheNodeResource, response.json()) @@ -4312,6 +4368,7 @@ def _delete_initial( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = True pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -4336,7 +4393,7 @@ def _delete_initial( response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() if cls: return cls(pipeline_response, deserialized, response_headers) # type: ignore @@ -4464,7 +4521,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -4477,7 +4537,10 @@ def prepare_request(next_link=None): def extract_data(pipeline_response): deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize(List[_models.EnterpriseMccCacheNodeResource], deserialized.get("value", [])) + list_of_elem = _deserialize( + List[_models.EnterpriseMccCacheNodeResource], + deserialized.get("value", []), + ) if cls: list_of_elem = cls(list_of_elem) # type: ignore return deserialized.get("nextLink") or None, iter(list_of_elem) @@ -4548,6 +4611,7 @@ def get_cache_node_install_details( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -4569,7 +4633,7 @@ def get_cache_node_install_details( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeInstallDetails, response.json()) @@ -4591,7 +4655,7 @@ def get_cache_node_install_details( "accept", ] }, - api_versions_list=["2024-11-30-preview"], + api_versions_list=["2024-11-30-preview", "2026-06-01"], ) def get_cache_node_auto_update_history( self, resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, **kwargs: Any @@ -4637,6 +4701,7 @@ def get_cache_node_auto_update_history( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -4658,7 +4723,7 @@ def get_cache_node_auto_update_history( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeAutoUpdateHistory, response.json()) @@ -4680,7 +4745,7 @@ def get_cache_node_auto_update_history( "accept", ] }, - api_versions_list=["2024-11-30-preview"], + api_versions_list=["2024-11-30-preview", "2026-06-01"], ) def get_cache_node_mcc_issue_details_history( self, resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, **kwargs: Any @@ -4726,6 +4791,7 @@ def get_cache_node_mcc_issue_details_history( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -4747,7 +4813,7 @@ def get_cache_node_mcc_issue_details_history( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeIssueHistory, response.json()) @@ -4769,7 +4835,7 @@ def get_cache_node_mcc_issue_details_history( "accept", ] }, - api_versions_list=["2024-11-30-preview"], + api_versions_list=["2024-11-30-preview", "2026-06-01"], ) def get_cache_node_tls_certificate_history( self, resource_group_name: str, customer_resource_name: str, cache_node_resource_name: str, **kwargs: Any @@ -4815,6 +4881,7 @@ def get_cache_node_tls_certificate_history( } _request.url = self._client.format_url(_request.url, **path_format_arguments) + _decompress = kwargs.pop("decompress", True) _stream = kwargs.pop("stream", False) pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access _request, stream=_stream, **kwargs @@ -4836,7 +4903,7 @@ def get_cache_node_tls_certificate_history( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if _stream: - deserialized = response.iter_bytes() + deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: deserialized = _deserialize(_models.MccCacheNodeTlsCertificateHistory, response.json()) diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/types.py b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/types.py new file mode 100644 index 000000000000..d33b97dc3064 --- /dev/null +++ b/sdk/connectedcache/azure-mgmt-connectedcache/azure/mgmt/connectedcache/types.py @@ -0,0 +1,1210 @@ +# pylint: disable=line-too-long,useless-suppression,too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) Python Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from typing import Any, TYPE_CHECKING, Union +from typing_extensions import Required, TypedDict + +if TYPE_CHECKING: + from .models import ( + AutoUpdateRingType, + BgpReviewStateEnum, + ConfigurationState, + CreatedByType, + CustomerTransitState, + OsType, + ProvisioningState, + ProxyRequired, + ) + + +class AdditionalCacheNodeProperties(TypedDict, total=False): + """Model representing cache node for connected cache resource. + + :ivar cache_node_properties_details_issues_list: issues list to return the issues as part of + the additional cache node properties. + :vartype cache_node_properties_details_issues_list: list[str] + :ivar issues_list: current cache node issue list. + :vartype issues_list: list[str] + :ivar issues_count: Number of cache node issues. + :vartype issues_count: int + :ivar current_tls_certificate: cache node current tls certificate. + :vartype current_tls_certificate: "MccCacheNodeTlsCertificate" + :ivar last_auto_update_info: cache node last auto update information. + :vartype last_auto_update_info: "MccCacheNodeAutoUpdateInfo" + :ivar aggregated_status_details: Cache node resource aggregated status details. + :vartype aggregated_status_details: str + :ivar aggregated_status_text: Cache node resource aggregated status text. + :vartype aggregated_status_text: str + :ivar aggregated_status_code: Cache node resource aggregated status code. + :vartype aggregated_status_code: int + :ivar product_version: Cache node resource Mcc product version. + :vartype product_version: str + :ivar is_provisioned: Cache node resource flag indicating if cache node has been physically + installed or provisioned on their physical lab. + :vartype is_provisioned: bool + :ivar cache_node_state_detailed_text: Cache node resource detailed state text. + :vartype cache_node_state_detailed_text: str + :ivar cache_node_state_short_text: Cache node resource short state text. + :vartype cache_node_state_short_text: str + :ivar cache_node_state: Cache node resource state as integer. + :vartype cache_node_state: int + :ivar drive_configuration: Cache node resource drive configurations. + :vartype drive_configuration: list["CacheNodeDriveConfiguration"] + :ivar bgp_configuration: Cache node resource Bgp configuration. + :vartype bgp_configuration: "BgpConfiguration" + :ivar proxy_url_configuration: proxyUrl configuration of the cache node. + :vartype proxy_url_configuration: "ProxyUrlConfiguration" + :ivar is_proxy_required: Cache node resource requires a proxy. Known values are: "None" and + "Required". + :vartype is_proxy_required: Union[str, "ProxyRequired"] + :ivar os_type: Operating system of the cache node. Known values are: "Windows", "Linux", and + "Eflow". + :vartype os_type: Union[str, "OsType"] + :ivar auto_update_version: Auto update or fast update version. + :vartype auto_update_version: str + :ivar update_info_details: Update related information details. + :vartype update_info_details: str + :ivar update_requested_date_time: customer requested date time for mcc install of update cycle. + :vartype update_requested_date_time: str + :ivar auto_update_next_available_version: Auto update version that is the Next available + version to update on mcc cache node. + :vartype auto_update_next_available_version: str + :ivar auto_update_next_available_date_time: Auto update last applied date time of mcc install. + :vartype auto_update_next_available_date_time: str + :ivar auto_update_applied_version: Auto update version that is the applied to update on mcc + cache node. + :vartype auto_update_applied_version: str + :ivar auto_update_last_applied_details: Auto Update status details from the backend after + applying the new version details. + :vartype auto_update_last_applied_details: str + :ivar auto_update_last_applied_state: Last applied auto update state for mcc install of auto + update cycle. + :vartype auto_update_last_applied_state: str + :ivar auto_update_last_applied_date_time: Auto update last applied date time of mcc install. + :vartype auto_update_last_applied_date_time: str + :ivar auto_update_last_triggered_date_time: Auto update last triggered date time of mcc + install. + :vartype auto_update_last_triggered_date_time: str + :ivar creation_method: Resource creation method of mcc cache node resource, cli or portal. + :vartype creation_method: int + :ivar tls_status: Cache node tls certificate status. + :vartype tls_status: str + :ivar host_os_edition: Operating system edition of the cache node host machine. + :vartype host_os_edition: str + :ivar host_os_version: Operating system version of the cache node host machine. + :vartype host_os_version: str + :ivar host_os_build: Operating system build of the cache node host machine. + :vartype host_os_build: str + :ivar distro_os_edition_wsl: Operating system edition of the WSL Linux distribution used to run + the cache node on Windows host machines. + :vartype distro_os_edition_wsl: str + :ivar distro_os_version_wsl: Operating system version of the WSL Linux distribution used to run + the cache node on Windows host machines. + :vartype distro_os_version_wsl: str + :ivar distro_os_build_wsl: Operating system build of the WSL Linux distribution used to run the + cache node on Windows host machines. + :vartype distro_os_build_wsl: str + :ivar container_os_edition: Operating system edition of container used to run the cache node. + :vartype container_os_edition: str + :ivar container_os_version: Operating system version of the container used to run the cache + node. + :vartype container_os_version: str + :ivar container_os_build: Operating system build of the container used to run the cache node. + :vartype container_os_build: str + :ivar install_version_msix: Version of the Windows deployment application used to deploy the + cache node. + :vartype install_version_msix: str + :ivar install_version_script: Version of the installation scripts used to deploy the cache + node. + :vartype install_version_script: str + :ivar app_version_wsl: Version of the Windows Subsystem for Linux application version used to + run the cache node on the Windows host machine. + :vartype app_version_wsl: str + :ivar optional_property1: Optional property #1 of Mcc response object. + :vartype optional_property1: str + :ivar optional_property2: Optional property #2 of Mcc response object. + :vartype optional_property2: str + :ivar optional_property3: Optional property #3 of Mcc response object. + :vartype optional_property3: str + :ivar optional_property4: Optional property #4 of Mcc response object. + :vartype optional_property4: str + :ivar optional_property5: Optional property #5 of Mcc response object. + :vartype optional_property5: str + """ + + cacheNodePropertiesDetailsIssuesList: list[str] + """issues list to return the issues as part of the additional cache node properties.""" + issuesList: list[str] + """current cache node issue list.""" + issuesCount: int + """Number of cache node issues.""" + currentTlsCertificate: "MccCacheNodeTlsCertificate" + """cache node current tls certificate.""" + lastAutoUpdateInfo: "MccCacheNodeAutoUpdateInfo" + """cache node last auto update information.""" + aggregatedStatusDetails: str + """Cache node resource aggregated status details.""" + aggregatedStatusText: str + """Cache node resource aggregated status text.""" + aggregatedStatusCode: int + """Cache node resource aggregated status code.""" + productVersion: str + """Cache node resource Mcc product version.""" + isProvisioned: bool + """Cache node resource flag indicating if cache node has been physically installed or provisioned + on their physical lab.""" + cacheNodeStateDetailedText: str + """Cache node resource detailed state text.""" + cacheNodeStateShortText: str + """Cache node resource short state text.""" + cacheNodeState: int + """Cache node resource state as integer.""" + driveConfiguration: list["CacheNodeDriveConfiguration"] + """Cache node resource drive configurations.""" + bgpConfiguration: "BgpConfiguration" + """Cache node resource Bgp configuration.""" + proxyUrlConfiguration: "ProxyUrlConfiguration" + """proxyUrl configuration of the cache node.""" + isProxyRequired: Union[str, "ProxyRequired"] + """Cache node resource requires a proxy. Known values are: \"None\" and \"Required\".""" + osType: Union[str, "OsType"] + """Operating system of the cache node. Known values are: \"Windows\", \"Linux\", and \"Eflow\".""" + autoUpdateVersion: str + """Auto update or fast update version.""" + updateInfoDetails: str + """Update related information details.""" + updateRequestedDateTime: str + """customer requested date time for mcc install of update cycle.""" + autoUpdateNextAvailableVersion: str + """Auto update version that is the Next available version to update on mcc cache node.""" + autoUpdateNextAvailableDateTime: str + """Auto update last applied date time of mcc install.""" + autoUpdateAppliedVersion: str + """Auto update version that is the applied to update on mcc cache node.""" + autoUpdateLastAppliedDetails: str + """Auto Update status details from the backend after applying the new version details.""" + autoUpdateLastAppliedState: str + """Last applied auto update state for mcc install of auto update cycle.""" + autoUpdateLastAppliedDateTime: str + """Auto update last applied date time of mcc install.""" + autoUpdateLastTriggeredDateTime: str + """Auto update last triggered date time of mcc install.""" + creationMethod: int + """Resource creation method of mcc cache node resource, cli or portal.""" + tlsStatus: str + """Cache node tls certificate status.""" + hostOsEdition: str + """Operating system edition of the cache node host machine.""" + hostOsVersion: str + """Operating system version of the cache node host machine.""" + hostOsBuild: str + """Operating system build of the cache node host machine.""" + distroOsEditionWsl: str + """Operating system edition of the WSL Linux distribution used to run the cache node on Windows + host machines.""" + distroOsVersionWsl: str + """Operating system version of the WSL Linux distribution used to run the cache node on Windows + host machines.""" + distroOsBuildWsl: str + """Operating system build of the WSL Linux distribution used to run the cache node on Windows host + machines.""" + containerOsEdition: str + """Operating system edition of container used to run the cache node.""" + containerOsVersion: str + """Operating system version of the container used to run the cache node.""" + containerOsBuild: str + """Operating system build of the container used to run the cache node.""" + installVersionMsix: str + """Version of the Windows deployment application used to deploy the cache node.""" + installVersionScript: str + """Version of the installation scripts used to deploy the cache node.""" + appVersionWsl: str + """Version of the Windows Subsystem for Linux application version used to run the cache node on + the Windows host machine.""" + optionalProperty1: str + """Optional property #1 of Mcc response object.""" + optionalProperty2: str + """Optional property #2 of Mcc response object.""" + optionalProperty3: str + """Optional property #3 of Mcc response object.""" + optionalProperty4: str + """Optional property #4 of Mcc response object.""" + optionalProperty5: str + """Optional property #5 of Mcc response object.""" + + +class AdditionalCustomerProperties(TypedDict, total=False): + """Model representing customer for connected cache resource. + + :ivar customer_properties_overview_cache_efficiency: Customer resource cache efficiency. + :vartype customer_properties_overview_cache_efficiency: float + :ivar customer_properties_overview_average_egress_mbps: Customer resource average egress in + Mbps. + :vartype customer_properties_overview_average_egress_mbps: float + :ivar customer_properties_overview_average_miss_mbps: Customer resource average cache miss + throughput in Mbps. + :vartype customer_properties_overview_average_miss_mbps: float + :ivar customer_properties_overview_egress_mbps_max: Customer resource maximum egress in Mbps. + :vartype customer_properties_overview_egress_mbps_max: float + :ivar customer_properties_overview_egress_mbps_max_date_time: Customer resource peak egress + timestamp. + :vartype customer_properties_overview_egress_mbps_max_date_time: str + :ivar customer_properties_overview_miss_mbps_max: Customer resource maximum cache miss + throughput in Mbps. + :vartype customer_properties_overview_miss_mbps_max: float + :ivar customer_properties_overview_miss_mbps_max_date_time: Customer resource peak cache miss + throughput timestamp. + :vartype customer_properties_overview_miss_mbps_max_date_time: str + :ivar customer_properties_overview_cache_nodes_healthy_count: Customer resource total healthy + cache nodes. + :vartype customer_properties_overview_cache_nodes_healthy_count: int + :ivar customer_properties_overview_cache_nodes_unhealthy_count: Customer resource total + unhealthy cache nodes. + :vartype customer_properties_overview_cache_nodes_unhealthy_count: int + :ivar signup_status: Customer resource signup status as boolean. + :vartype signup_status: bool + :ivar signup_status_code: Customer resource signup status as integer code. + :vartype signup_status_code: int + :ivar signup_status_text: Customer resource signup status as string text. + :vartype signup_status_text: str + :ivar signup_phase_status_code: Customer resource signup phase status code as integer. + :vartype signup_phase_status_code: int + :ivar signup_phase_status_text: Customer resource signup phase status as string text. + :vartype signup_phase_status_text: str + :ivar peering_db_last_update_date: Customer resource last PeeringDB update timestamp. + :vartype peering_db_last_update_date: str + :ivar customer_org_name: Customer resource owner organization name. + :vartype customer_org_name: str + :ivar customer_email: Customer resource contact email. + :vartype customer_email: str + :ivar customer_transit_asn: Customer resource transit Asn (autonomous system number). + :vartype customer_transit_asn: str + :ivar customer_transit_state: Customer resource transit state. Known values are: "NoTransit", + "CombinedTransit", and "TransitOnly". + :vartype customer_transit_state: Union[str, "CustomerTransitState"] + :ivar customer_asn: Customer resource Asn (autonomous system number). + :vartype customer_asn: str + :ivar customer_asn_estimated_egress_peek_gbps: Customer resource estimated Asn peering peak in + Gbps. + :vartype customer_asn_estimated_egress_peek_gbps: float + :ivar customer_entitlement_sku_id: Customer resource entitlement Sku Id. + :vartype customer_entitlement_sku_id: str + :ivar customer_entitlement_sku_guid: Customer resource entitlement Sku Guid. + :vartype customer_entitlement_sku_guid: str + :ivar customer_entitlement_sku_name: Customer resource entitlement Sku name. + :vartype customer_entitlement_sku_name: str + :ivar customer_entitlement_expiration: Customer resource entitlement expiration date string. + :vartype customer_entitlement_expiration: str + :ivar optional_property1: Optional property #1 of Mcc response object. + :vartype optional_property1: str + :ivar optional_property2: Optional property #2 of Mcc response object. + :vartype optional_property2: str + :ivar optional_property3: Optional property #3 of Mcc response object. + :vartype optional_property3: str + :ivar optional_property4: Optional property #4 of Mcc response object. + :vartype optional_property4: str + :ivar optional_property5: Optional property #5 of Mcc response object. + :vartype optional_property5: str + """ + + customerPropertiesOverviewCacheEfficiency: float + """Customer resource cache efficiency.""" + customerPropertiesOverviewAverageEgressMbps: float + """Customer resource average egress in Mbps.""" + customerPropertiesOverviewAverageMissMbps: float + """Customer resource average cache miss throughput in Mbps.""" + customerPropertiesOverviewEgressMbpsMax: float + """Customer resource maximum egress in Mbps.""" + customerPropertiesOverviewEgressMbpsMaxDateTime: str + """Customer resource peak egress timestamp.""" + customerPropertiesOverviewMissMbpsMax: float + """Customer resource maximum cache miss throughput in Mbps.""" + customerPropertiesOverviewMissMbpsMaxDateTime: str + """Customer resource peak cache miss throughput timestamp.""" + customerPropertiesOverviewCacheNodesHealthyCount: int + """Customer resource total healthy cache nodes.""" + customerPropertiesOverviewCacheNodesUnhealthyCount: int + """Customer resource total unhealthy cache nodes.""" + signupStatus: bool + """Customer resource signup status as boolean.""" + signupStatusCode: int + """Customer resource signup status as integer code.""" + signupStatusText: str + """Customer resource signup status as string text.""" + signupPhaseStatusCode: int + """Customer resource signup phase status code as integer.""" + signupPhaseStatusText: str + """Customer resource signup phase status as string text.""" + peeringDbLastUpdateDate: str + """Customer resource last PeeringDB update timestamp.""" + customerOrgName: str + """Customer resource owner organization name.""" + customerEmail: str + """Customer resource contact email.""" + customerTransitAsn: str + """Customer resource transit Asn (autonomous system number).""" + customerTransitState: Union[str, "CustomerTransitState"] + """Customer resource transit state. Known values are: \"NoTransit\", \"CombinedTransit\", and + \"TransitOnly\".""" + customerAsn: str + """Customer resource Asn (autonomous system number).""" + customerAsnEstimatedEgressPeekGbps: float + """Customer resource estimated Asn peering peak in Gbps.""" + customerEntitlementSkuId: str + """Customer resource entitlement Sku Id.""" + customerEntitlementSkuGuid: str + """Customer resource entitlement Sku Guid.""" + customerEntitlementSkuName: str + """Customer resource entitlement Sku name.""" + customerEntitlementExpiration: str + """Customer resource entitlement expiration date string.""" + optionalProperty1: str + """Optional property #1 of Mcc response object.""" + optionalProperty2: str + """Optional property #2 of Mcc response object.""" + optionalProperty3: str + """Optional property #3 of Mcc response object.""" + optionalProperty4: str + """Optional property #4 of Mcc response object.""" + optionalProperty5: str + """Optional property #5 of Mcc response object.""" + + +class BgpConfiguration(TypedDict, total=False): + """Bgp configuration of cache node. + + :ivar asn_to_ip_address_mapping: Asn to ip address mapping. + :vartype asn_to_ip_address_mapping: str + """ + + asnToIpAddressMapping: str + """Asn to ip address mapping.""" + + +class CacheNodeDriveConfiguration(TypedDict, total=False): + """Drive configuration for cache node. + + :ivar physical_path: physical path location of the folder used for caching content. + :vartype physical_path: str + :ivar size_in_gb: physical size of the drive used for caching content. + :vartype size_in_gb: int + :ivar cache_number: corresponding nginx cache number. Valid cache numbers are 1 - 20. + :vartype cache_number: int + :ivar nginx_mapping: full binding for corresponding nginx cache drive. + :vartype nginx_mapping: str + """ + + physicalPath: str + """physical path location of the folder used for caching content.""" + sizeInGb: int + """physical size of the drive used for caching content.""" + cacheNumber: int + """corresponding nginx cache number. Valid cache numbers are 1 - 20.""" + nginxMapping: str + """full binding for corresponding nginx cache drive.""" + + +class CacheNodeEntity(TypedDict, total=False): + """Model representing Cache Node for ConnectedCache resource. + + :ivar fully_qualified_resource_id: Cache node resource Azure fully qualified resource Id. + :vartype fully_qualified_resource_id: str + :ivar customer_id: Cache node resource customer resource GUID Id. + :vartype customer_id: str + :ivar customer_name: Cache node resource customer resource name. + :vartype customer_name: str + :ivar ip_address: Cache node resource Ip address. + :vartype ip_address: str + :ivar customer_index: Cache node resource customer index as string. + :vartype customer_index: str + :ivar cache_node_id: Cache node resource identifier of the cache node. + :vartype cache_node_id: str + :ivar cache_node_name: Cache node resource name. + :vartype cache_node_name: str + :ivar customer_asn: Cache node resource customer resource Asn (autonomous system number). + :vartype customer_asn: int + :ivar is_enabled: Cache node resource flag for indicating if cache node is enabled. + :vartype is_enabled: bool + :ivar max_allowable_egress_in_mbps: Cache node resource maximum allowed egress in Mbps. + :vartype max_allowable_egress_in_mbps: int + :ivar max_allowable_probability: Cache node resource maximum allowed probability of egress. + :vartype max_allowable_probability: float + :ivar x_cid: Cache node resource Azure XCid. + :vartype x_cid: str + :ivar is_enterprise_managed: Cache node resource flag for determining if managed by enterprise + as boolean. + :vartype is_enterprise_managed: bool + :ivar create_async_operation_id: Cache node resource create async operation Id. + :vartype create_async_operation_id: str + :ivar delete_async_operation_id: Cache node resource deletion async operation Id. + :vartype delete_async_operation_id: str + :ivar client_tenant_id: Cache node resource customer resource client tenant Id of subscription. + :vartype client_tenant_id: str + :ivar category: Cache node resource category. + :vartype category: str + :ivar release_version: Cache node resource release version. + :vartype release_version: int + :ivar last_sync_with_azure_timestamp: Cache node resource last sync timestamp. + :vartype last_sync_with_azure_timestamp: str + :ivar last_updated_timestamp: Cache node resource last backend updated timestamp. + :vartype last_updated_timestamp: str + :ivar synch_with_azure_attempts_count: Cache node resource attempts to sync with Azure. + :vartype synch_with_azure_attempts_count: int + :ivar container_configurations: Cache node resource container configuration details. + :vartype container_configurations: str + :ivar cidr_csv: Cache node resource comma separated values of Cidrs. + :vartype cidr_csv: list[str] + :ivar cidr_csv_last_update_time: Cache node resource last Cidr Csv update timestamp. + :vartype cidr_csv_last_update_time: str + :ivar bgp_network_interface: Cache node resource Bgp network interface. + :vartype bgp_network_interface: str + :ivar bgp_cidr_csv_last_update_time: Cache node resource last Bgp Cidr Csv update timestamp. + :vartype bgp_cidr_csv_last_update_time: str + :ivar bgp_last_reported_time: Cache node resource last Bgp report timestamp. + :vartype bgp_last_reported_time: str + :ivar bgp_review_state_text: Cache node resource Bgp review state string text in detail. + :vartype bgp_review_state_text: str + :ivar bgp_review_state: Cache node resource Bgp review state string text. Known values are: + "NotConfigured", "InReview", "Approved", and "AttentionRequired". + :vartype bgp_review_state: Union[str, "BgpReviewStateEnum"] + :ivar bgp_review_feedback: Cache node resource Bgp review feedback text. + :vartype bgp_review_feedback: str + :ivar bgp_number_of_times_updated: Cache node resource Bgp update count. + :vartype bgp_number_of_times_updated: int + :ivar bgp_number_of_records: Cache node resource Bgp record count. + :vartype bgp_number_of_records: int + :ivar bgp_cidr_blocks_count: Cache node resource Bgp block count. + :vartype bgp_cidr_blocks_count: int + :ivar bgp_address_space: Cache node resource total addressable space defined by Bgp and Cidr + Csv blocks. + :vartype bgp_address_space: int + :ivar should_migrate: Cache node resource flag for determining if customer will be migrated. + :vartype should_migrate: bool + :ivar bgp_file_bytes_truncated: Cache node resource bytes truncated from Bgp output file. + :vartype bgp_file_bytes_truncated: int + :ivar cidr_selection_type: Cache node resource current Cidr range precedence selection type. + :vartype cidr_selection_type: int + :ivar is_frozen: Cache node resource flag for indicating the cache node resource is frozen (not + selectable, not editable in UI). + :vartype is_frozen: bool + :ivar review_state: Cache node resource review process state as integer. + :vartype review_state: int + :ivar review_state_text: Cache node resource review state text. + :vartype review_state_text: str + :ivar review_feedback: Cache node resource review feedback text. + :vartype review_feedback: str + :ivar configuration_state: Cache node resource configuration state. Known values are: + "Configured" and "NotConfigured_Ip". + :vartype configuration_state: Union[str, "ConfigurationState"] + :ivar configuration_state_text: Cache node resource configuration state text. + :vartype configuration_state_text: str + :ivar address_space: Cache node resource total addressable space defined by the Cidr Csv block. + :vartype address_space: int + :ivar worker_connections: Cache node resource Mcc container deployment worker connection count. + :vartype worker_connections: int + :ivar worker_connections_last_updated_date_time: Cache node resource last updated Mcc container + deployment worker connection count timestamp. + :vartype worker_connections_last_updated_date_time: str + :ivar container_resync_trigger: Cache node resource Mcc container configuration details re-sync + trigger. + :vartype container_resync_trigger: int + :ivar image_uri: Cache node resource Mcc Container Id Uri. + :vartype image_uri: str + :ivar fully_qualified_domain_name: FQDN(fully qualified domain name) value of the mcc cache + node. + :vartype fully_qualified_domain_name: str + :ivar auto_update_ring_type: Auto Update Ring Type which is stable or beta as new values. slow + or fast are legacy from version 2026-06-01. Known values are: "Preview", "Slow", "Fast", + "Stable", and "Beta". + :vartype auto_update_ring_type: Union[str, "AutoUpdateRingType"] + :ivar auto_update_requested_week: Customer requested week of month for mcc install of auto + update cycle. 0 is default no selection. 1-5 are valid weeks of month, 1 is first week, 2 is + second week, etc. + :vartype auto_update_requested_week: int + :ivar auto_update_requested_day: Customer requested day of week for mcc install of auto update + cycle. 0 is default no selection. 1-7 are days of week, 1 is Sunday, 2 is Monday, etc. + :vartype auto_update_requested_day: int + :ivar auto_update_requested_time: Customer requested time of the day for mcc install of auto + update cycle, should be hh:mm. + :vartype auto_update_requested_time: str + :ivar open_firewall_port80: Cache node port firewall rule creation opt-in for port 80 property. + :vartype open_firewall_port80: bool + :ivar open_firewall_port443: Cache node port firewall rule creation opt-in for port 443 + property. + :vartype open_firewall_port443: bool + :ivar open_firewall_port5000: Cache node port firewall rule creation opt-in for port 5000 + property. + :vartype open_firewall_port5000: bool + :ivar open_firewall_port5001: Cache node port firewall rule creation opt-in for port 5001 + property. + :vartype open_firewall_port5001: bool + :ivar runtime_account_type: Connected Cache runtime account type. + :vartype runtime_account_type: str + """ + + fullyQualifiedResourceId: str + """Cache node resource Azure fully qualified resource Id.""" + customerId: str + """Cache node resource customer resource GUID Id.""" + customerName: str + """Cache node resource customer resource name.""" + ipAddress: str + """Cache node resource Ip address.""" + customerIndex: str + """Cache node resource customer index as string.""" + cacheNodeId: str + """Cache node resource identifier of the cache node.""" + cacheNodeName: str + """Cache node resource name.""" + customerAsn: int + """Cache node resource customer resource Asn (autonomous system number).""" + isEnabled: bool + """Cache node resource flag for indicating if cache node is enabled.""" + maxAllowableEgressInMbps: int + """Cache node resource maximum allowed egress in Mbps.""" + maxAllowableProbability: float + """Cache node resource maximum allowed probability of egress.""" + xCid: str + """Cache node resource Azure XCid.""" + isEnterpriseManaged: bool + """Cache node resource flag for determining if managed by enterprise as boolean.""" + createAsyncOperationId: str + """Cache node resource create async operation Id.""" + deleteAsyncOperationId: str + """Cache node resource deletion async operation Id.""" + clientTenantId: str + """Cache node resource customer resource client tenant Id of subscription.""" + category: str + """Cache node resource category.""" + releaseVersion: int + """Cache node resource release version.""" + lastSyncWithAzureTimestamp: str + """Cache node resource last sync timestamp.""" + lastUpdatedTimestamp: str + """Cache node resource last backend updated timestamp.""" + synchWithAzureAttemptsCount: int + """Cache node resource attempts to sync with Azure.""" + containerConfigurations: str + """Cache node resource container configuration details.""" + cidrCsv: list[str] + """Cache node resource comma separated values of Cidrs.""" + cidrCsvLastUpdateTime: str + """Cache node resource last Cidr Csv update timestamp.""" + bgpNetworkInterface: str + """Cache node resource Bgp network interface.""" + bgpCidrCsvLastUpdateTime: str + """Cache node resource last Bgp Cidr Csv update timestamp.""" + bgpLastReportedTime: str + """Cache node resource last Bgp report timestamp.""" + bgpReviewStateText: str + """Cache node resource Bgp review state string text in detail.""" + bgpReviewState: Union[str, "BgpReviewStateEnum"] + """Cache node resource Bgp review state string text. Known values are: \"NotConfigured\", + \"InReview\", \"Approved\", and \"AttentionRequired\".""" + bgpReviewFeedback: str + """Cache node resource Bgp review feedback text.""" + bgpNumberOfTimesUpdated: int + """Cache node resource Bgp update count.""" + bgpNumberOfRecords: int + """Cache node resource Bgp record count.""" + bgpCidrBlocksCount: int + """Cache node resource Bgp block count.""" + bgpAddressSpace: int + """Cache node resource total addressable space defined by Bgp and Cidr Csv blocks.""" + shouldMigrate: bool + """Cache node resource flag for determining if customer will be migrated.""" + bgpFileBytesTruncated: int + """Cache node resource bytes truncated from Bgp output file.""" + cidrSelectionType: int + """Cache node resource current Cidr range precedence selection type.""" + isFrozen: bool + """Cache node resource flag for indicating the cache node resource is frozen (not selectable, not + editable in UI).""" + reviewState: int + """Cache node resource review process state as integer.""" + reviewStateText: str + """Cache node resource review state text.""" + reviewFeedback: str + """Cache node resource review feedback text.""" + configurationState: Union[str, "ConfigurationState"] + """Cache node resource configuration state. Known values are: \"Configured\" and + \"NotConfigured_Ip\".""" + configurationStateText: str + """Cache node resource configuration state text.""" + addressSpace: int + """Cache node resource total addressable space defined by the Cidr Csv block.""" + workerConnections: int + """Cache node resource Mcc container deployment worker connection count.""" + workerConnectionsLastUpdatedDateTime: str + """Cache node resource last updated Mcc container deployment worker connection count timestamp.""" + containerResyncTrigger: int + """Cache node resource Mcc container configuration details re-sync trigger.""" + imageUri: str + """Cache node resource Mcc Container Id Uri.""" + fullyQualifiedDomainName: str + """FQDN(fully qualified domain name) value of the mcc cache node.""" + autoUpdateRingType: Union[str, "AutoUpdateRingType"] + """Auto Update Ring Type which is stable or beta as new values. slow or fast are legacy from + version 2026-06-01. Known values are: \"Preview\", \"Slow\", \"Fast\", \"Stable\", and + \"Beta\".""" + autoUpdateRequestedWeek: int + """Customer requested week of month for mcc install of auto update cycle. 0 is default no + selection. 1-5 are valid weeks of month, 1 is first week, 2 is second week, etc.""" + autoUpdateRequestedDay: int + """Customer requested day of week for mcc install of auto update cycle. 0 is default no selection. + 1-7 are days of week, 1 is Sunday, 2 is Monday, etc.""" + autoUpdateRequestedTime: str + """Customer requested time of the day for mcc install of auto update cycle, should be hh:mm.""" + openFirewallPort80: bool + """Cache node port firewall rule creation opt-in for port 80 property.""" + openFirewallPort443: bool + """Cache node port firewall rule creation opt-in for port 443 property.""" + openFirewallPort5000: bool + """Cache node port firewall rule creation opt-in for port 5000 property.""" + openFirewallPort5001: bool + """Cache node port firewall rule creation opt-in for port 5001 property.""" + runtimeAccountType: str + """Connected Cache runtime account type.""" + + +class CacheNodeProperty(TypedDict, total=False): + """Model representing an Mcc cache node connectedCache resource. + + :ivar provisioning_state: The provisioned state of the resource. Known values are: "Succeeded", + "Failed", "Canceled", "Unknown", "Accepted", "Upgrading", and "Deleting". + :vartype provisioning_state: Union[str, "ProvisioningState"] + :ivar cache_node: Mcc cache node resource (cache node entity). + :vartype cache_node: "CacheNodeEntity" + :ivar additional_cache_node_properties: Mcc cache node resource additional properties. + :vartype additional_cache_node_properties: "AdditionalCacheNodeProperties" + :ivar status_code: Mcc response status code. + :vartype status_code: str + :ivar status_text: Mcc response status text as string for retrieving status details. + :vartype status_text: str + :ivar status_details: Mcc response status details for retrieving response inner details. + :vartype status_details: str + :ivar status: HTTP error status code. + :vartype status: str + :ivar error: Mcc response error details. + :vartype error: "ErrorDetail" + """ + + provisioningState: Union[str, "ProvisioningState"] + """The provisioned state of the resource. Known values are: \"Succeeded\", \"Failed\", + \"Canceled\", \"Unknown\", \"Accepted\", \"Upgrading\", and \"Deleting\".""" + cacheNode: "CacheNodeEntity" + """Mcc cache node resource (cache node entity).""" + additionalCacheNodeProperties: "AdditionalCacheNodeProperties" + """Mcc cache node resource additional properties.""" + statusCode: str + """Mcc response status code.""" + statusText: str + """Mcc response status text as string for retrieving status details.""" + statusDetails: str + """Mcc response status details for retrieving response inner details.""" + status: str + """HTTP error status code.""" + error: "ErrorDetail" + """Mcc response error details.""" + + +class ConnectedCachePatchResource(TypedDict, total=False): + """Mcc PATCH operation properties. + + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + """ + + tags: dict[str, str] + """Resource tags.""" + + +class CustomerEntity(TypedDict, total=False): + """Model representing Customer resource for ConnectedCache resource. + + :ivar fully_qualified_resource_id: Customer resource Azure fully qualified resource Id. + :vartype fully_qualified_resource_id: str + :ivar customer_id: Customer resource Guid Id. + :vartype customer_id: str + :ivar customer_name: Customer resource name. + :vartype customer_name: str + :ivar contact_email: Customer resource contact email. + :vartype contact_email: str + :ivar contact_phone: Customer resource contact phone. + :vartype contact_phone: str + :ivar contact_name: Customer resource contact full name. + :vartype contact_name: str + :ivar is_entitled: Customer resource entitlement flag as boolean. + :vartype is_entitled: bool + :ivar release_version: Customer resource Mcc release version. + :vartype release_version: int + :ivar create_async_operation_id: Customer resource create async operation Id. + :vartype create_async_operation_id: str + :ivar delete_async_operation_id: Customer resource deletion async operation Id. + :vartype delete_async_operation_id: str + :ivar client_tenant_id: Customer resource client tenant Id of subscription. + :vartype client_tenant_id: str + :ivar synch_with_azure_attempts_count: Customer resource sync attempts. + :vartype synch_with_azure_attempts_count: int + :ivar last_sync_with_azure_timestamp: Customer resource last Azure sync timestamp. + :vartype last_sync_with_azure_timestamp: str + :ivar is_enterprise_managed: Customer resource flag for enterprise management as boolean. + :vartype is_enterprise_managed: bool + :ivar should_migrate: Customer resource flag for migration. + :vartype should_migrate: bool + :ivar resend_signup_code: Customer resource flag for resending signup code as boolean. + :vartype resend_signup_code: bool + :ivar verify_signup_code: Customer resource flag for requiring verification of signup code as + boolean. + :vartype verify_signup_code: bool + :ivar verify_signup_phrase: Customer resource phrase for verifying signup. + :vartype verify_signup_phrase: str + """ + + fullyQualifiedResourceId: str + """Customer resource Azure fully qualified resource Id.""" + customerId: str + """Customer resource Guid Id.""" + customerName: str + """Customer resource name.""" + contactEmail: str + """Customer resource contact email.""" + contactPhone: str + """Customer resource contact phone.""" + contactName: str + """Customer resource contact full name.""" + isEntitled: bool + """Customer resource entitlement flag as boolean.""" + releaseVersion: int + """Customer resource Mcc release version.""" + createAsyncOperationId: str + """Customer resource create async operation Id.""" + deleteAsyncOperationId: str + """Customer resource deletion async operation Id.""" + clientTenantId: str + """Customer resource client tenant Id of subscription.""" + synchWithAzureAttemptsCount: int + """Customer resource sync attempts.""" + lastSyncWithAzureTimestamp: str + """Customer resource last Azure sync timestamp.""" + isEnterpriseManaged: bool + """Customer resource flag for enterprise management as boolean.""" + shouldMigrate: bool + """Customer resource flag for migration.""" + resendSignupCode: bool + """Customer resource flag for resending signup code as boolean.""" + verifySignupCode: bool + """Customer resource flag for requiring verification of signup code as boolean.""" + verifySignupPhrase: str + """Customer resource phrase for verifying signup.""" + + +class CustomerProperty(TypedDict, total=False): + """Model representing customer for connectedCache resource. + + :ivar provisioning_state: The provisioned state of the resource. Known values are: "Succeeded", + "Failed", "Canceled", "Unknown", "Accepted", "Upgrading", and "Deleting". + :vartype provisioning_state: Union[str, "ProvisioningState"] + :ivar customer: Mcc customer resource (customer entity). + :vartype customer: "CustomerEntity" + :ivar additional_customer_properties: Mcc customer resource additional properties. + :vartype additional_customer_properties: "AdditionalCustomerProperties" + :ivar status_code: Mcc response status code. + :vartype status_code: str + :ivar status_text: Mcc response status text as string for retrieving status details. + :vartype status_text: str + :ivar status_details: Mcc response status details for retrieving response inner details. + :vartype status_details: str + :ivar status: HTTP error status code. + :vartype status: str + :ivar error: Mcc response error details. + :vartype error: "ErrorDetail" + """ + + provisioningState: Union[str, "ProvisioningState"] + """The provisioned state of the resource. Known values are: \"Succeeded\", \"Failed\", + \"Canceled\", \"Unknown\", \"Accepted\", \"Upgrading\", and \"Deleting\".""" + customer: "CustomerEntity" + """Mcc customer resource (customer entity).""" + additionalCustomerProperties: "AdditionalCustomerProperties" + """Mcc customer resource additional properties.""" + statusCode: str + """Mcc response status code.""" + statusText: str + """Mcc response status text as string for retrieving status details.""" + statusDetails: str + """Mcc response status details for retrieving response inner details.""" + status: str + """HTTP error status code.""" + error: "ErrorDetail" + """Mcc response error details.""" + + +class Resource(TypedDict, total=False): + """Resource. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: "SystemData" + """ + + id: str + """Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.""" + name: str + """The name of the resource.""" + type: str + """The type of the resource. E.g. \"Microsoft.Compute/virtualMachines\" or + \"Microsoft.Storage/storageAccounts\".""" + systemData: "SystemData" + """Azure Resource Manager metadata containing createdBy and modifiedBy information.""" + + +class TrackedResource(Resource): + """Tracked Resource. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: "SystemData" + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + :ivar location: The geo-location where the resource lives. Required. + :vartype location: str + """ + + tags: dict[str, str] + """Resource tags.""" + location: Required[str] + """The geo-location where the resource lives. Required.""" + + +class EnterpriseMccCacheNodeResource(TrackedResource): + """Represents the high level Nodes needed to provision cache node resources. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: "SystemData" + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + :ivar location: The geo-location where the resource lives. Required. + :vartype location: str + :ivar properties: The resource-specific properties for this resource. + :vartype properties: "CacheNodeProperty" + """ + + properties: "CacheNodeProperty" + """The resource-specific properties for this resource.""" + + +class EnterpriseMccCustomerResource(TrackedResource): + """Represents the high level Nodes needed to provision customer resources. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: "SystemData" + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + :ivar location: The geo-location where the resource lives. Required. + :vartype location: str + :ivar properties: The resource-specific properties for this resource. + :vartype properties: "CustomerProperty" + """ + + properties: "CustomerProperty" + """The resource-specific properties for this resource.""" + + +class ErrorAdditionalInfo(TypedDict, total=False): + """The resource management error additional info. + + :ivar type: The additional info type. + :vartype type: str + :ivar info: The additional info. + :vartype info: Any + """ + + type: str + """The additional info type.""" + info: Any + """The additional info.""" + + +class ErrorDetail(TypedDict, total=False): + """The error detail. + + :ivar code: The error code. + :vartype code: str + :ivar message: The error message. + :vartype message: str + :ivar target: The error target. + :vartype target: str + :ivar details: The error details. + :vartype details: list["ErrorDetail"] + :ivar additional_info: The error additional info. + :vartype additional_info: list["ErrorAdditionalInfo"] + """ + + code: str + """The error code.""" + message: str + """The error message.""" + target: str + """The error target.""" + details: list["ErrorDetail"] + """The error details.""" + additionalInfo: list["ErrorAdditionalInfo"] + """The error additional info.""" + + +class IspCacheNodeResource(TrackedResource): + """Represents the high level Nodes needed to provision cache node resources. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: "SystemData" + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + :ivar location: The geo-location where the resource lives. Required. + :vartype location: str + :ivar properties: The resource-specific properties for this resource. + :vartype properties: "CacheNodeProperty" + """ + + properties: "CacheNodeProperty" + """The resource-specific properties for this resource.""" + + +class IspCustomerResource(TrackedResource): + """Represents the high level Nodes needed to provision isp customer resources. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: "SystemData" + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + :ivar location: The geo-location where the resource lives. Required. + :vartype location: str + :ivar properties: The resource-specific properties for this resource. + :vartype properties: "CustomerProperty" + """ + + properties: "CustomerProperty" + """The resource-specific properties for this resource.""" + + +class MccCacheNodeAutoUpdateInfo(TypedDict, total=False): + """Mcc cache node resource auto update properties. + + :ivar image_uri_before_update: Auto update image uri before update. + :vartype image_uri_before_update: str + :ivar image_uri_targeted: Auto update image uri targetted to update. + :vartype image_uri_targeted: str + :ivar image_uri_terminal: Auto update image uri at Terminal. + :vartype image_uri_terminal: str + :ivar auto_update_ring_type: Auto update Ring Type. + :vartype auto_update_ring_type: int + :ivar moved_to_terminal_state_date_time: Auto update image uri after update. + :vartype moved_to_terminal_state_date_time: str + :ivar rule_requested_week: Auto update image uri before update. + :vartype rule_requested_week: int + :ivar rule_requested_day: Auto update image uri after update. + :vartype rule_requested_day: int + :ivar created_date_time_utc: Auto update entity created datetime. + :vartype created_date_time_utc: str + :ivar updated_registry_date_time_utc: Auto update entity last updated datetime. + :vartype updated_registry_date_time_utc: str + :ivar plan_change_log_text: This text describing the purpose of the plan of auto update. + :vartype plan_change_log_text: str + :ivar auto_update_last_applied_status: Auto update last applied status. + :vartype auto_update_last_applied_status: int + :ivar auto_update_last_applied_status_text: Auto update last applied status text. + :vartype auto_update_last_applied_status_text: str + :ivar auto_update_last_applied_status_detailed_text: Auto update last applied detailed status + text. + :vartype auto_update_last_applied_status_detailed_text: str + :ivar plan_id: Auto update planId. + :vartype plan_id: int + :ivar time_to_go_live_date_time: Auto update time to go live date time. + :vartype time_to_go_live_date_time: str + :ivar rule_requested_minute: Auto update rule requested minute. + :vartype rule_requested_minute: str + :ivar rule_requested_hour: Auto update rule requested hour. + :vartype rule_requested_hour: str + """ + + imageUriBeforeUpdate: str + """Auto update image uri before update.""" + imageUriTargeted: str + """Auto update image uri targetted to update.""" + imageUriTerminal: str + """Auto update image uri at Terminal.""" + autoUpdateRingType: int + """Auto update Ring Type.""" + movedToTerminalStateDateTime: str + """Auto update image uri after update.""" + ruleRequestedWeek: int + """Auto update image uri before update.""" + ruleRequestedDay: int + """Auto update image uri after update.""" + createdDateTimeUtc: str + """Auto update entity created datetime.""" + updatedRegistryDateTimeUtc: str + """Auto update entity last updated datetime.""" + planChangeLogText: str + """This text describing the purpose of the plan of auto update.""" + autoUpdateLastAppliedStatus: int + """Auto update last applied status.""" + autoUpdateLastAppliedStatusText: str + """Auto update last applied status text.""" + autoUpdateLastAppliedStatusDetailedText: str + """Auto update last applied detailed status text.""" + planId: int + """Auto update planId.""" + timeToGoLiveDateTime: str + """Auto update time to go live date time.""" + ruleRequestedMinute: str + """Auto update rule requested minute.""" + ruleRequestedHour: str + """Auto update rule requested hour.""" + + +class MccCacheNodeTlsCertificate(TypedDict, total=False): + """Mcc cache node resource Tls certificate details. + + :ivar action_required: Mcc cache node Tls certificate status. + :vartype action_required: str + :ivar certificate_file_name: Mcc cache node Tls certificate file name. + :vartype certificate_file_name: str + :ivar cert_type: Mcc cache node Tls certificate Type. + :vartype cert_type: str + :ivar thumbprint: Mcc cache node Tls certificate thumbprint. + :vartype thumbprint: str + :ivar expiry_date: Mcc cache node Tls certificate expiry date. + :vartype expiry_date: str + :ivar not_before_date: Mcc cache node Tls certificate not before date. + :vartype not_before_date: str + :ivar subject: Mcc cache node Tls certificate subject name. + :vartype subject: str + :ivar subject_alt_name: Mcc cache node Tls certificate subject alternate name. + :vartype subject_alt_name: str + """ + + actionRequired: str + """Mcc cache node Tls certificate status.""" + certificateFileName: str + """Mcc cache node Tls certificate file name.""" + certType: str + """Mcc cache node Tls certificate Type.""" + thumbprint: str + """Mcc cache node Tls certificate thumbprint.""" + expiryDate: str + """Mcc cache node Tls certificate expiry date.""" + notBeforeDate: str + """Mcc cache node Tls certificate not before date.""" + subject: str + """Mcc cache node Tls certificate subject name.""" + subjectAltName: str + """Mcc cache node Tls certificate subject alternate name.""" + + +class ProxyUrlConfiguration(TypedDict, total=False): + """ProxyUrl configuration of cache node. + + :ivar proxy_url: Host Proxy Address configuration along with port number. This can be a proxy + or ip address. ex: xx.xx.xx.xxxx:80 or host name `http://exampleproxy.com:80 + `_. + :vartype proxy_url: str + """ + + proxyUrl: str + """Host Proxy Address configuration along with port number. This can be a proxy or ip address. ex: + xx.xx.xx.xxxx:80 or host name `http://exampleproxy.com:80 `_.""" + + +class SystemData(TypedDict, total=False): + """Metadata pertaining to creation and last modification of the resource. + + :ivar created_by: The identity that created the resource. + :vartype created_by: str + :ivar created_by_type: The type of identity that created the resource. Known values are: + "User", "Application", "ManagedIdentity", and "Key". + :vartype created_by_type: Union[str, "CreatedByType"] + :ivar created_at: The timestamp of resource creation (UTC). + :vartype created_at: str + :ivar last_modified_by: The identity that last modified the resource. + :vartype last_modified_by: str + :ivar last_modified_by_type: The type of identity that last modified the resource. Known values + are: "User", "Application", "ManagedIdentity", and "Key". + :vartype last_modified_by_type: Union[str, "CreatedByType"] + :ivar last_modified_at: The timestamp of resource last modification (UTC). + :vartype last_modified_at: str + """ + + createdBy: str + """The identity that created the resource.""" + createdByType: Union[str, "CreatedByType"] + """The type of identity that created the resource. Known values are: \"User\", \"Application\", + \"ManagedIdentity\", and \"Key\".""" + createdAt: str + """The timestamp of resource creation (UTC).""" + lastModifiedBy: str + """The identity that last modified the resource.""" + lastModifiedByType: Union[str, "CreatedByType"] + """The type of identity that last modified the resource. Known values are: \"User\", + \"Application\", \"ManagedIdentity\", and \"Key\".""" + lastModifiedAt: str + """The timestamp of resource last modification (UTC).""" diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_create_or_update_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_create_or_update_maximum_set_gen.py index a39bc5c6f53e..48609e1eda6a 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_create_or_update_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_create_or_update_maximum_set_gen.py @@ -69,6 +69,10 @@ def main(): "isEnabled": True, "isEnterpriseManaged": True, "maxAllowableEgressInMbps": 27, + "openFirewallPort443": False, + "openFirewallPort5000": False, + "openFirewallPort5001": True, + "openFirewallPort80": True, "shouldMigrate": True, }, "error": {}, @@ -82,6 +86,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/EnterpriseMccCacheNodesOperations_CreateOrUpdate_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/EnterpriseMccCacheNodesOperations_CreateOrUpdate_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_delete_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_delete_maximum_set_gen.py index 2454d2c25d74..7b86bde970cc 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_delete_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_delete_maximum_set_gen.py @@ -37,6 +37,6 @@ def main(): ).result() -# x-ms-original-file: 2024-11-30-preview/EnterpriseMccCacheNodesOperations_Delete_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/EnterpriseMccCacheNodesOperations_Delete_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_auto_update_history_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_auto_update_history_maximum_set_gen.py index e2e5ceaa1d8f..53c86107e708 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_auto_update_history_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_auto_update_history_maximum_set_gen.py @@ -1,4 +1,3 @@ -# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -39,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/EnterpriseMccCacheNodesOperations_GetCacheNodeAutoUpdateHistory_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/EnterpriseMccCacheNodesOperations_GetCacheNodeAutoUpdateHistory_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_install_details_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_install_details_maximum_set_gen.py index 14e1e4b2f34a..84c421bc9ce2 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_install_details_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_install_details_maximum_set_gen.py @@ -1,4 +1,3 @@ -# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -39,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/EnterpriseMccCacheNodesOperations_GetCacheNodeInstallDetails_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/EnterpriseMccCacheNodesOperations_GetCacheNodeInstallDetails_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_mcc_issue_details_history_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_mcc_issue_details_history_maximum_set_gen.py index 573f080ee833..2b9536a09db2 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_mcc_issue_details_history_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_mcc_issue_details_history_maximum_set_gen.py @@ -39,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/EnterpriseMccCacheNodesOperations_GetCacheNodeMccIssueDetailsHistory_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/EnterpriseMccCacheNodesOperations_GetCacheNodeMccIssueDetailsHistory_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_tls_certificate_history_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_tls_certificate_history_maximum_set_gen.py index b1b1d5ea3a5f..1574915eac6e 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_tls_certificate_history_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_cache_node_tls_certificate_history_maximum_set_gen.py @@ -1,4 +1,3 @@ -# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -39,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/EnterpriseMccCacheNodesOperations_GetCacheNodeTlsCertificateHistory_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/EnterpriseMccCacheNodesOperations_GetCacheNodeTlsCertificateHistory_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_maximum_set_gen.py index ed58b95629d5..809aebaeb890 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_get_maximum_set_gen.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/EnterpriseMccCacheNodesOperations_Get_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/EnterpriseMccCacheNodesOperations_Get_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_list_by_enterprise_mcc_customer_resource_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_list_by_enterprise_mcc_customer_resource_maximum_set_gen.py index d6b732cf8976..3f1385682ec5 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_list_by_enterprise_mcc_customer_resource_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_list_by_enterprise_mcc_customer_resource_maximum_set_gen.py @@ -39,6 +39,6 @@ def main(): print(item) -# x-ms-original-file: 2024-11-30-preview/EnterpriseMccCacheNodesOperations_ListByEnterpriseMccCustomerResource_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/EnterpriseMccCacheNodesOperations_ListByEnterpriseMccCustomerResource_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_update_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_update_maximum_set_gen.py index 9ec8c88d9790..6e2831766562 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_update_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_cache_nodes_operations_update_maximum_set_gen.py @@ -39,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/EnterpriseMccCacheNodesOperations_Update_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/EnterpriseMccCacheNodesOperations_Update_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_create_or_update_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_create_or_update_maximum_set_gen.py index df54d1135653..1cfb2972bb24 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_create_or_update_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_create_or_update_maximum_set_gen.py @@ -74,6 +74,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/EnterpriseMccCustomers_CreateOrUpdate_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/EnterpriseMccCustomers_CreateOrUpdate_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_delete_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_delete_maximum_set_gen.py index 49ecb223ad8e..184f25514ff2 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_delete_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_delete_maximum_set_gen.py @@ -36,6 +36,6 @@ def main(): ).result() -# x-ms-original-file: 2024-11-30-preview/EnterpriseMccCustomers_Delete_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/EnterpriseMccCustomers_Delete_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_get_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_get_maximum_set_gen.py index c12c1190c21b..d1c65afb5c5b 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_get_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_get_maximum_set_gen.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/EnterpriseMccCustomers_Get_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/EnterpriseMccCustomers_Get_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_list_by_resource_group_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_list_by_resource_group_maximum_set_gen.py index 593917b8ce4f..69952ed8ba7d 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_list_by_resource_group_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_list_by_resource_group_maximum_set_gen.py @@ -37,6 +37,6 @@ def main(): print(item) -# x-ms-original-file: 2024-11-30-preview/EnterpriseMccCustomers_ListByResourceGroup_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/EnterpriseMccCustomers_ListByResourceGroup_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_list_by_subscription_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_list_by_subscription_maximum_set_gen.py index 9eb0748830e6..d972c7e8d2a4 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_list_by_subscription_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_list_by_subscription_maximum_set_gen.py @@ -35,6 +35,6 @@ def main(): print(item) -# x-ms-original-file: 2024-11-30-preview/EnterpriseMccCustomers_ListBySubscription_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/EnterpriseMccCustomers_ListBySubscription_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_update_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_update_maximum_set_gen.py index 4ee5e835ca41..235824912c5d 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_update_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/enterprise_mcc_customers_update_maximum_set_gen.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/EnterpriseMccCustomers_Update_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/EnterpriseMccCustomers_Update_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_create_or_update_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_create_or_update_maximum_set_gen.py index de35f53810e1..d6564d88d573 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_create_or_update_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_create_or_update_maximum_set_gen.py @@ -76,6 +76,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/IspCacheNodesOperations_CreateOrUpdate_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/IspCacheNodesOperations_CreateOrUpdate_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_delete_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_delete_maximum_set_gen.py index d6822d634ab7..dfb544024bad 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_delete_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_delete_maximum_set_gen.py @@ -37,6 +37,6 @@ def main(): ).result() -# x-ms-original-file: 2024-11-30-preview/IspCacheNodesOperations_Delete_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/IspCacheNodesOperations_Delete_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_bgp_cidrs_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_bgp_cidrs_maximum_set_gen.py index 37587b0066d8..5db6a7969339 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_bgp_cidrs_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_bgp_cidrs_maximum_set_gen.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/IspCacheNodesOperations_GetBgpCidrs_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/IspCacheNodesOperations_GetBgpCidrs_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_cache_node_auto_update_history_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_cache_node_auto_update_history_maximum_set_gen.py index 184e98a71182..c280efe29c31 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_cache_node_auto_update_history_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_cache_node_auto_update_history_maximum_set_gen.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/IspCacheNodesOperations_GetCacheNodeAutoUpdateHistory_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/IspCacheNodesOperations_GetCacheNodeAutoUpdateHistory_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_cache_node_install_details_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_cache_node_install_details_maximum_set_gen.py index 67a3483be6ef..f25899291c71 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_cache_node_install_details_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_cache_node_install_details_maximum_set_gen.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/IspCacheNodesOperations_GetCacheNodeInstallDetails_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/IspCacheNodesOperations_GetCacheNodeInstallDetails_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_cache_node_mcc_issue_details_history_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_cache_node_mcc_issue_details_history_maximum_set_gen.py index e7517d93ec3e..4b5d2dbbbcb1 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_cache_node_mcc_issue_details_history_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_cache_node_mcc_issue_details_history_maximum_set_gen.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/IspCacheNodesOperations_GetCacheNodeMccIssueDetailsHistory_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/IspCacheNodesOperations_GetCacheNodeMccIssueDetailsHistory_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_maximum_set_gen.py index b90d51bae540..a499af53311d 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_get_maximum_set_gen.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/IspCacheNodesOperations_Get_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/IspCacheNodesOperations_Get_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_list_by_isp_customer_resource_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_list_by_isp_customer_resource_maximum_set_gen.py index 29cc10dce920..382c73106dbd 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_list_by_isp_customer_resource_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_list_by_isp_customer_resource_maximum_set_gen.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: 2024-11-30-preview/IspCacheNodesOperations_ListByIspCustomerResource_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/IspCacheNodesOperations_ListByIspCustomerResource_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_update_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_update_maximum_set_gen.py index e76d8442ff27..1e6f59ee70c2 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_update_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_cache_nodes_operations_update_maximum_set_gen.py @@ -39,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/IspCacheNodesOperations_Update_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/IspCacheNodesOperations_Update_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_create_or_update_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_create_or_update_maximum_set_gen.py index 09a90edaf509..8fc8a72880ea 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_create_or_update_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_create_or_update_maximum_set_gen.py @@ -74,6 +74,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/IspCustomers_CreateOrUpdate_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/IspCustomers_CreateOrUpdate_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_delete_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_delete_maximum_set_gen.py index 1152c8491bc6..9ca07e0ddfce 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_delete_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_delete_maximum_set_gen.py @@ -36,6 +36,6 @@ def main(): ).result() -# x-ms-original-file: 2024-11-30-preview/IspCustomers_Delete_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/IspCustomers_Delete_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_get_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_get_maximum_set_gen.py index bb1f4bf25fc1..fc63e34b6b96 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_get_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_get_maximum_set_gen.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/IspCustomers_Get_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/IspCustomers_Get_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_list_by_resource_group_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_list_by_resource_group_maximum_set_gen.py index 9d2c26c7ec26..6c11d2db27c5 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_list_by_resource_group_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_list_by_resource_group_maximum_set_gen.py @@ -37,6 +37,6 @@ def main(): print(item) -# x-ms-original-file: 2024-11-30-preview/IspCustomers_ListByResourceGroup_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/IspCustomers_ListByResourceGroup_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_list_by_subscription_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_list_by_subscription_maximum_set_gen.py index 72eb5afc174e..ff50b2c91eb3 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_list_by_subscription_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_list_by_subscription_maximum_set_gen.py @@ -35,6 +35,6 @@ def main(): print(item) -# x-ms-original-file: 2024-11-30-preview/IspCustomers_ListBySubscription_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/IspCustomers_ListBySubscription_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_update_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_update_maximum_set_gen.py index 72f4af0e6199..ff026b0370cd 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_update_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/isp_customers_update_maximum_set_gen.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2024-11-30-preview/IspCustomers_Update_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/IspCustomers_Update_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/operations_list_maximum_set_gen.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/operations_list_maximum_set_gen.py index 83b663143f54..0936b7f4566e 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/operations_list_maximum_set_gen.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_samples/operations_list_maximum_set_gen.py @@ -35,6 +35,6 @@ def main(): print(item) -# x-ms-original-file: 2024-11-30-preview/Operations_List_MaximumSet_Gen.json +# x-ms-original-file: 2026-06-01/Operations_List_MaximumSet_Gen.json if __name__ == "__main__": main() diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_enterprise_mcc_cache_nodes_operations_operations.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_enterprise_mcc_cache_nodes_operations_operations.py index 037cd7f7c059..98c366c6467e 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_enterprise_mcc_cache_nodes_operations_operations.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_enterprise_mcc_cache_nodes_operations_operations.py @@ -46,6 +46,7 @@ def test_enterprise_mcc_cache_nodes_operations_begin_create_or_update(self, reso "aggregatedStatusCode": 0, "aggregatedStatusDetails": "str", "aggregatedStatusText": "str", + "appVersionWsl": "str", "autoUpdateAppliedVersion": "str", "autoUpdateLastAppliedDateTime": "2020-02-20 00:00:00", "autoUpdateLastAppliedDetails": "str", @@ -59,9 +60,13 @@ def test_enterprise_mcc_cache_nodes_operations_begin_create_or_update(self, reso "cacheNodeState": 0, "cacheNodeStateDetailedText": "str", "cacheNodeStateShortText": "str", + "containerOsBuild": "str", + "containerOsEdition": "str", + "containerOsVersion": "str", "creationMethod": 0, "currentTlsCertificate": { "actionRequired": "str", + "certType": "str", "certificateFileName": "str", "expiryDate": "2020-02-20 00:00:00", "notBeforeDate": "2020-02-20 00:00:00", @@ -69,9 +74,17 @@ def test_enterprise_mcc_cache_nodes_operations_begin_create_or_update(self, reso "subjectAltName": "str", "thumbprint": "str", }, + "distroOsBuildWsl": "str", + "distroOsEditionWsl": "str", + "distroOsVersionWsl": "str", "driveConfiguration": [ {"cacheNumber": 0, "nginxMapping": "str", "physicalPath": "str", "sizeInGb": 0} ], + "hostOsBuild": "str", + "hostOsEdition": "str", + "hostOsVersion": "str", + "installVersionMsix": "str", + "installVersionScript": "str", "isProvisioned": bool, "isProxyRequired": "str", "issuesCount": 0, @@ -118,6 +131,7 @@ def test_enterprise_mcc_cache_nodes_operations_begin_create_or_update(self, reso "bgpCidrCsvLastUpdateTime": "2020-02-20 00:00:00", "bgpFileBytesTruncated": 0, "bgpLastReportedTime": "2020-02-20 00:00:00", + "bgpNetworkInterface": "str", "bgpNumberOfRecords": 0, "bgpNumberOfTimesUpdated": 0, "bgpReviewFeedback": "str", @@ -151,10 +165,15 @@ def test_enterprise_mcc_cache_nodes_operations_begin_create_or_update(self, reso "lastUpdatedTimestamp": "2020-02-20 00:00:00", "maxAllowableEgressInMbps": 0, "maxAllowableProbability": 0.0, + "openFirewallPort443": bool, + "openFirewallPort5000": bool, + "openFirewallPort5001": bool, + "openFirewallPort80": bool, "releaseVersion": 0, "reviewFeedback": "str", "reviewState": 0, "reviewStateText": "str", + "runtimeAccountType": "str", "shouldMigrate": bool, "synchWithAzureAttemptsCount": 0, "workerConnections": 0, diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_enterprise_mcc_cache_nodes_operations_operations_async.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_enterprise_mcc_cache_nodes_operations_operations_async.py index 9c9e03acaf5b..6158ee5df927 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_enterprise_mcc_cache_nodes_operations_operations_async.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_enterprise_mcc_cache_nodes_operations_operations_async.py @@ -48,6 +48,7 @@ async def test_enterprise_mcc_cache_nodes_operations_begin_create_or_update(self "aggregatedStatusCode": 0, "aggregatedStatusDetails": "str", "aggregatedStatusText": "str", + "appVersionWsl": "str", "autoUpdateAppliedVersion": "str", "autoUpdateLastAppliedDateTime": "2020-02-20 00:00:00", "autoUpdateLastAppliedDetails": "str", @@ -61,9 +62,13 @@ async def test_enterprise_mcc_cache_nodes_operations_begin_create_or_update(self "cacheNodeState": 0, "cacheNodeStateDetailedText": "str", "cacheNodeStateShortText": "str", + "containerOsBuild": "str", + "containerOsEdition": "str", + "containerOsVersion": "str", "creationMethod": 0, "currentTlsCertificate": { "actionRequired": "str", + "certType": "str", "certificateFileName": "str", "expiryDate": "2020-02-20 00:00:00", "notBeforeDate": "2020-02-20 00:00:00", @@ -71,9 +76,17 @@ async def test_enterprise_mcc_cache_nodes_operations_begin_create_or_update(self "subjectAltName": "str", "thumbprint": "str", }, + "distroOsBuildWsl": "str", + "distroOsEditionWsl": "str", + "distroOsVersionWsl": "str", "driveConfiguration": [ {"cacheNumber": 0, "nginxMapping": "str", "physicalPath": "str", "sizeInGb": 0} ], + "hostOsBuild": "str", + "hostOsEdition": "str", + "hostOsVersion": "str", + "installVersionMsix": "str", + "installVersionScript": "str", "isProvisioned": bool, "isProxyRequired": "str", "issuesCount": 0, @@ -120,6 +133,7 @@ async def test_enterprise_mcc_cache_nodes_operations_begin_create_or_update(self "bgpCidrCsvLastUpdateTime": "2020-02-20 00:00:00", "bgpFileBytesTruncated": 0, "bgpLastReportedTime": "2020-02-20 00:00:00", + "bgpNetworkInterface": "str", "bgpNumberOfRecords": 0, "bgpNumberOfTimesUpdated": 0, "bgpReviewFeedback": "str", @@ -153,10 +167,15 @@ async def test_enterprise_mcc_cache_nodes_operations_begin_create_or_update(self "lastUpdatedTimestamp": "2020-02-20 00:00:00", "maxAllowableEgressInMbps": 0, "maxAllowableProbability": 0.0, + "openFirewallPort443": bool, + "openFirewallPort5000": bool, + "openFirewallPort5001": bool, + "openFirewallPort80": bool, "releaseVersion": 0, "reviewFeedback": "str", "reviewState": 0, "reviewStateText": "str", + "runtimeAccountType": "str", "shouldMigrate": bool, "synchWithAzureAttemptsCount": 0, "workerConnections": 0, diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_isp_cache_nodes_operations_operations.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_isp_cache_nodes_operations_operations.py index 1a4599621200..abe8f2d71f6c 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_isp_cache_nodes_operations_operations.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_isp_cache_nodes_operations_operations.py @@ -46,6 +46,7 @@ def test_isp_cache_nodes_operations_begin_create_or_update(self, resource_group) "aggregatedStatusCode": 0, "aggregatedStatusDetails": "str", "aggregatedStatusText": "str", + "appVersionWsl": "str", "autoUpdateAppliedVersion": "str", "autoUpdateLastAppliedDateTime": "2020-02-20 00:00:00", "autoUpdateLastAppliedDetails": "str", @@ -59,9 +60,13 @@ def test_isp_cache_nodes_operations_begin_create_or_update(self, resource_group) "cacheNodeState": 0, "cacheNodeStateDetailedText": "str", "cacheNodeStateShortText": "str", + "containerOsBuild": "str", + "containerOsEdition": "str", + "containerOsVersion": "str", "creationMethod": 0, "currentTlsCertificate": { "actionRequired": "str", + "certType": "str", "certificateFileName": "str", "expiryDate": "2020-02-20 00:00:00", "notBeforeDate": "2020-02-20 00:00:00", @@ -69,9 +74,17 @@ def test_isp_cache_nodes_operations_begin_create_or_update(self, resource_group) "subjectAltName": "str", "thumbprint": "str", }, + "distroOsBuildWsl": "str", + "distroOsEditionWsl": "str", + "distroOsVersionWsl": "str", "driveConfiguration": [ {"cacheNumber": 0, "nginxMapping": "str", "physicalPath": "str", "sizeInGb": 0} ], + "hostOsBuild": "str", + "hostOsEdition": "str", + "hostOsVersion": "str", + "installVersionMsix": "str", + "installVersionScript": "str", "isProvisioned": bool, "isProxyRequired": "str", "issuesCount": 0, @@ -118,6 +131,7 @@ def test_isp_cache_nodes_operations_begin_create_or_update(self, resource_group) "bgpCidrCsvLastUpdateTime": "2020-02-20 00:00:00", "bgpFileBytesTruncated": 0, "bgpLastReportedTime": "2020-02-20 00:00:00", + "bgpNetworkInterface": "str", "bgpNumberOfRecords": 0, "bgpNumberOfTimesUpdated": 0, "bgpReviewFeedback": "str", @@ -151,10 +165,15 @@ def test_isp_cache_nodes_operations_begin_create_or_update(self, resource_group) "lastUpdatedTimestamp": "2020-02-20 00:00:00", "maxAllowableEgressInMbps": 0, "maxAllowableProbability": 0.0, + "openFirewallPort443": bool, + "openFirewallPort5000": bool, + "openFirewallPort5001": bool, + "openFirewallPort80": bool, "releaseVersion": 0, "reviewFeedback": "str", "reviewState": 0, "reviewStateText": "str", + "runtimeAccountType": "str", "shouldMigrate": bool, "synchWithAzureAttemptsCount": 0, "workerConnections": 0, diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_isp_cache_nodes_operations_operations_async.py b/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_isp_cache_nodes_operations_operations_async.py index 32162cb04965..cdda726d370c 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_isp_cache_nodes_operations_operations_async.py +++ b/sdk/connectedcache/azure-mgmt-connectedcache/generated_tests/test_connected_cache_mgmt_isp_cache_nodes_operations_operations_async.py @@ -48,6 +48,7 @@ async def test_isp_cache_nodes_operations_begin_create_or_update(self, resource_ "aggregatedStatusCode": 0, "aggregatedStatusDetails": "str", "aggregatedStatusText": "str", + "appVersionWsl": "str", "autoUpdateAppliedVersion": "str", "autoUpdateLastAppliedDateTime": "2020-02-20 00:00:00", "autoUpdateLastAppliedDetails": "str", @@ -61,9 +62,13 @@ async def test_isp_cache_nodes_operations_begin_create_or_update(self, resource_ "cacheNodeState": 0, "cacheNodeStateDetailedText": "str", "cacheNodeStateShortText": "str", + "containerOsBuild": "str", + "containerOsEdition": "str", + "containerOsVersion": "str", "creationMethod": 0, "currentTlsCertificate": { "actionRequired": "str", + "certType": "str", "certificateFileName": "str", "expiryDate": "2020-02-20 00:00:00", "notBeforeDate": "2020-02-20 00:00:00", @@ -71,9 +76,17 @@ async def test_isp_cache_nodes_operations_begin_create_or_update(self, resource_ "subjectAltName": "str", "thumbprint": "str", }, + "distroOsBuildWsl": "str", + "distroOsEditionWsl": "str", + "distroOsVersionWsl": "str", "driveConfiguration": [ {"cacheNumber": 0, "nginxMapping": "str", "physicalPath": "str", "sizeInGb": 0} ], + "hostOsBuild": "str", + "hostOsEdition": "str", + "hostOsVersion": "str", + "installVersionMsix": "str", + "installVersionScript": "str", "isProvisioned": bool, "isProxyRequired": "str", "issuesCount": 0, @@ -120,6 +133,7 @@ async def test_isp_cache_nodes_operations_begin_create_or_update(self, resource_ "bgpCidrCsvLastUpdateTime": "2020-02-20 00:00:00", "bgpFileBytesTruncated": 0, "bgpLastReportedTime": "2020-02-20 00:00:00", + "bgpNetworkInterface": "str", "bgpNumberOfRecords": 0, "bgpNumberOfTimesUpdated": 0, "bgpReviewFeedback": "str", @@ -153,10 +167,15 @@ async def test_isp_cache_nodes_operations_begin_create_or_update(self, resource_ "lastUpdatedTimestamp": "2020-02-20 00:00:00", "maxAllowableEgressInMbps": 0, "maxAllowableProbability": 0.0, + "openFirewallPort443": bool, + "openFirewallPort5000": bool, + "openFirewallPort5001": bool, + "openFirewallPort80": bool, "releaseVersion": 0, "reviewFeedback": "str", "reviewState": 0, "reviewStateText": "str", + "runtimeAccountType": "str", "shouldMigrate": bool, "synchWithAzureAttemptsCount": 0, "workerConnections": 0, diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/pyproject.toml b/sdk/connectedcache/azure-mgmt-connectedcache/pyproject.toml index b8e1d72f82c1..380221f11e1f 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/pyproject.toml +++ b/sdk/connectedcache/azure-mgmt-connectedcache/pyproject.toml @@ -17,13 +17,13 @@ classifiers = [ "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", "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", ] -requires-python = ">=3.9" +requires-python = ">=3.10" keywords = [ "azure", "azure sdk", diff --git a/sdk/connectedcache/azure-mgmt-connectedcache/tsp-location.yaml b/sdk/connectedcache/azure-mgmt-connectedcache/tsp-location.yaml index ae6822914b92..d1eb0eff0b97 100644 --- a/sdk/connectedcache/azure-mgmt-connectedcache/tsp-location.yaml +++ b/sdk/connectedcache/azure-mgmt-connectedcache/tsp-location.yaml @@ -1,4 +1,4 @@ directory: specification/connectedcache/ConnectedCache.Management -commit: be46becafeb29aa993898709e35759d3643b2809 +commit: 7b08703f0340226430bd8838aad0d7ac4ab5a665 repo: Azure/azure-rest-api-specs additionalDirectories: