diff --git a/sdk/computelimit/azure-mgmt-computelimit/CHANGELOG.md b/sdk/computelimit/azure-mgmt-computelimit/CHANGELOG.md index f6863866297a..76257b50c462 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/CHANGELOG.md +++ b/sdk/computelimit/azure-mgmt-computelimit/CHANGELOG.md @@ -1,5 +1,21 @@ # Release History +## 1.2.0 (2026-06-17) + +### Features Added + + - Client `ComputeLimitMgmtClient` added operation group `shared_limit_caps` + - Client `ComputeLimitMgmtClient` added operation group `member_cap_overrides` + - Added model `MemberCap` + - Added model `MemberCapOverride` + - Added model `MemberCapOverrideProperties` + - Added model `SetMemberCapOverridesRequest` + - Added model `SetMemberCapOverridesResult` + - Added model `SharedLimitCap` + - Added model `SharedLimitCapProperties` + - Added operation group `MemberCapOverridesOperations` + - Added operation group `SharedLimitCapsOperations` + ## 1.1.0 (2026-05-26) ### Features Added diff --git a/sdk/computelimit/azure-mgmt-computelimit/README.md b/sdk/computelimit/azure-mgmt-computelimit/README.md index c1bb1023f9c5..a4cd047522d7 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/README.md +++ b/sdk/computelimit/azure-mgmt-computelimit/README.md @@ -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/computelimit/azure-mgmt-computelimit/_metadata.json b/sdk/computelimit/azure-mgmt-computelimit/_metadata.json index 3dcd218cdce8..1408b9ff06b6 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/_metadata.json +++ b/sdk/computelimit/azure-mgmt-computelimit/_metadata.json @@ -1,10 +1,11 @@ { - "apiVersion": "2026-06-01", + "apiVersion": "2026-07-01", "apiVersions": { - "Microsoft.ComputeLimit": "2026-06-01" + "Microsoft.ComputeLimit": "2026-07-01" }, - "commit": "5376576f4c7cd72c82446ddaab93642c9fad6b6e", + "commit": "2114bd7b79b2ff5604db83ebd706b81632cb0ea0", "repository_url": "https://github.com/Azure/azure-rest-api-specs", "typespec_src": "specification/computelimit/resource-manager/Microsoft.ComputeLimit/ComputeLimit", - "emitterVersion": "0.62.1" + "emitterVersion": "0.63.1", + "httpClientPythonVersion": "^0.32.0" } \ No newline at end of file diff --git a/sdk/computelimit/azure-mgmt-computelimit/api.md b/sdk/computelimit/azure-mgmt-computelimit/api.md new file mode 100644 index 000000000000..a8e3c8d27556 --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/api.md @@ -0,0 +1,1303 @@ +```py +namespace azure.mgmt.computelimit + + class azure.mgmt.computelimit.ComputeLimitMgmtClient: implements ContextManager + features: FeaturesOperations + guest_subscriptions: GuestSubscriptionsOperations + member_cap_overrides: MemberCapOverridesOperations + operations: Operations + shared_limit_caps: SharedLimitCapsOperations + shared_limits: SharedLimitsOperations + vm_families: VmFamiliesOperations + + 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.computelimit.aio + + class azure.mgmt.computelimit.aio.ComputeLimitMgmtClient: implements AsyncContextManager + features: FeaturesOperations + guest_subscriptions: GuestSubscriptionsOperations + member_cap_overrides: MemberCapOverridesOperations + operations: Operations + shared_limit_caps: SharedLimitCapsOperations + shared_limits: SharedLimitsOperations + vm_families: VmFamiliesOperations + + 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.computelimit.aio.operations + + class azure.mgmt.computelimit.aio.operations.FeaturesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2026-04-30', params_added_on={'2026-04-30': ['api_version', 'subscription_id', 'location', 'feature_name', 'accept']}, api_versions_list=['2026-04-30', '2026-06-01', '2026-07-01']) + async def begin_disable( + self, + location: str, + feature_name: str, + **kwargs: Any + ) -> AsyncLROPoller[OperationStatusResult]: ... + + @overload + async def begin_enable( + self, + location: str, + feature_name: str, + body: Optional[FeatureEnableRequest] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[OperationStatusResult]: ... + + @overload + async def begin_enable( + self, + location: str, + feature_name: str, + body: Optional[JSON] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[OperationStatusResult]: ... + + @overload + async def begin_enable( + self, + location: str, + feature_name: str, + body: Optional[IO[bytes]] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[OperationStatusResult]: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2026-03-20', params_added_on={'2026-03-20': ['api_version', 'subscription_id', 'location', 'feature_name', 'accept']}, api_versions_list=['2026-03-20', '2026-04-30', '2026-06-01', '2026-07-01']) + async def get( + self, + location: str, + feature_name: str, + **kwargs: Any + ) -> Feature: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-03-20', params_added_on={'2026-03-20': ['api_version', 'subscription_id', 'location', 'accept']}, api_versions_list=['2026-03-20', '2026-04-30', '2026-06-01', '2026-07-01']) + def list_by_subscription_location_resource( + self, + location: str, + **kwargs: Any + ) -> AsyncItemPaged[Feature]: ... + + + class azure.mgmt.computelimit.aio.operations.GuestSubscriptionsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def create( + self, + location: str, + guest_subscription_id: str, + resource: GuestSubscription, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> GuestSubscription: ... + + @overload + async def create( + self, + location: str, + guest_subscription_id: str, + resource: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> GuestSubscription: ... + + @overload + async def create( + self, + location: str, + guest_subscription_id: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> GuestSubscription: ... + + @distributed_trace_async + async def delete( + self, + location: str, + guest_subscription_id: str, + **kwargs: Any + ) -> None: ... + + @distributed_trace_async + async def get( + self, + location: str, + guest_subscription_id: str, + **kwargs: Any + ) -> GuestSubscription: ... + + @distributed_trace + def list_by_subscription_location_resource( + self, + location: str, + **kwargs: Any + ) -> AsyncItemPaged[GuestSubscription]: ... + + + class azure.mgmt.computelimit.aio.operations.MemberCapOverridesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def create_or_update( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + resource: MemberCapOverride, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> MemberCapOverride: ... + + @overload + async def create_or_update( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + resource: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> MemberCapOverride: ... + + @overload + async def create_or_update( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> MemberCapOverride: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2026-07-01', params_added_on={'2026-07-01': ['api_version', 'subscription_id', 'location', 'vm_family_name', 'member_subscription_id']}, api_versions_list=['2026-07-01']) + async def delete( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + **kwargs: Any + ) -> None: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2026-07-01', params_added_on={'2026-07-01': ['api_version', 'subscription_id', 'location', 'vm_family_name', 'member_subscription_id', 'accept']}, api_versions_list=['2026-07-01']) + async def get( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + **kwargs: Any + ) -> MemberCapOverride: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-07-01', params_added_on={'2026-07-01': ['api_version', 'subscription_id', 'location', 'vm_family_name', 'accept']}, api_versions_list=['2026-07-01']) + def list_by_parent( + self, + location: str, + vm_family_name: str, + **kwargs: Any + ) -> AsyncItemPaged[MemberCapOverride]: ... + + + class azure.mgmt.computelimit.aio.operations.Operations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list(self, **kwargs: Any) -> AsyncItemPaged[Operation]: ... + + + class azure.mgmt.computelimit.aio.operations.SharedLimitCapsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def create_or_update( + self, + location: str, + vm_family_name: str, + resource: SharedLimitCap, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SharedLimitCap: ... + + @overload + async def create_or_update( + self, + location: str, + vm_family_name: str, + resource: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SharedLimitCap: ... + + @overload + async def create_or_update( + self, + location: str, + vm_family_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SharedLimitCap: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2026-07-01', params_added_on={'2026-07-01': ['api_version', 'subscription_id', 'location', 'vm_family_name']}, api_versions_list=['2026-07-01']) + async def delete( + self, + location: str, + vm_family_name: str, + **kwargs: Any + ) -> None: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2026-07-01', params_added_on={'2026-07-01': ['api_version', 'subscription_id', 'location', 'vm_family_name', 'accept']}, api_versions_list=['2026-07-01']) + async def get( + self, + location: str, + vm_family_name: str, + **kwargs: Any + ) -> SharedLimitCap: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-07-01', params_added_on={'2026-07-01': ['api_version', 'subscription_id', 'location', 'accept']}, api_versions_list=['2026-07-01']) + def list_by_subscription_location_resource( + self, + location: str, + **kwargs: Any + ) -> AsyncItemPaged[SharedLimitCap]: ... + + @overload + async def set_member_cap_overrides( + self, + location: str, + vm_family_name: str, + body: SetMemberCapOverridesRequest, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SetMemberCapOverridesResult: ... + + @overload + async def set_member_cap_overrides( + self, + location: str, + vm_family_name: str, + body: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SetMemberCapOverridesResult: ... + + @overload + async def set_member_cap_overrides( + self, + location: str, + vm_family_name: str, + body: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SetMemberCapOverridesResult: ... + + + class azure.mgmt.computelimit.aio.operations.SharedLimitsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def create( + self, + location: str, + name: str, + resource: SharedLimit, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SharedLimit: ... + + @overload + async def create( + self, + location: str, + name: str, + resource: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SharedLimit: ... + + @overload + async def create( + self, + location: str, + name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SharedLimit: ... + + @distributed_trace_async + async def delete( + self, + location: str, + name: str, + **kwargs: Any + ) -> None: ... + + @distributed_trace_async + async def get( + self, + location: str, + name: str, + **kwargs: Any + ) -> SharedLimit: ... + + @distributed_trace + def list_by_subscription_location_resource( + self, + location: str, + **kwargs: Any + ) -> AsyncItemPaged[SharedLimit]: ... + + + class azure.mgmt.computelimit.aio.operations.VmFamiliesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2026-04-30', params_added_on={'2026-04-30': ['api_version', 'subscription_id', 'location', 'vm_family_name', 'accept']}, api_versions_list=['2026-04-30', '2026-06-01', '2026-07-01']) + async def get( + self, + location: str, + vm_family_name: str, + **kwargs: Any + ) -> VmFamily: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-04-30', params_added_on={'2026-04-30': ['api_version', 'subscription_id', 'location', 'filter', 'accept']}, api_versions_list=['2026-04-30', '2026-06-01', '2026-07-01']) + def list_by_subscription_location_resource( + self, + location: str, + *, + filter: Optional[str] = ..., + **kwargs: Any + ) -> AsyncItemPaged[VmFamily]: ... + + +namespace azure.mgmt.computelimit.models + + class azure.mgmt.computelimit.models.ActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INTERNAL = "Internal" + + + class azure.mgmt.computelimit.models.CreatedByType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + APPLICATION = "Application" + KEY = "Key" + MANAGED_IDENTITY = "ManagedIdentity" + USER = "User" + + + class azure.mgmt.computelimit.models.ErrorAdditionalInfo(_Model): + info: Optional[Any] + type: Optional[str] + + + class azure.mgmt.computelimit.models.ErrorDetail(_Model): + additional_info: Optional[list[ErrorAdditionalInfo]] + code: Optional[str] + details: Optional[list[ErrorDetail]] + message: Optional[str] + target: Optional[str] + + + class azure.mgmt.computelimit.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.computelimit.models.Feature(ProxyResource): + id: str + name: str + properties: Optional[FeatureProperties] + system_data: SystemData + type: str + + @overload + def __init__( + self, + *, + properties: Optional[FeatureProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.computelimit.models.FeatureEnableRequest(_Model): + service_tree_id: Optional[str] + + @overload + def __init__( + self, + *, + service_tree_id: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.computelimit.models.FeatureProperties(_Model): + provisioning_state: Optional[Union[str, ResourceProvisioningState]] + state: Optional[Union[str, FeatureState]] + + @overload + def __init__( + self, + *, + state: Optional[Union[str, FeatureState]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.computelimit.models.FeatureState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + + + class azure.mgmt.computelimit.models.GuestSubscription(ProxyResource): + id: str + name: str + properties: Optional[GuestSubscriptionProperties] + system_data: SystemData + type: str + + @overload + def __init__( + self, + *, + properties: Optional[GuestSubscriptionProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.computelimit.models.GuestSubscriptionProperties(_Model): + provisioning_state: Optional[Union[str, ResourceProvisioningState]] + + + class azure.mgmt.computelimit.models.LimitName(_Model): + localized_value: Optional[str] + value: str + + @overload + def __init__( + self, + *, + value: str + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.computelimit.models.MemberCap(_Model): + cap: int + subscription_id: str + + @overload + def __init__( + self, + *, + cap: int, + subscription_id: str + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.computelimit.models.MemberCapOverride(ProxyResource): + id: str + name: str + properties: Optional[MemberCapOverrideProperties] + system_data: SystemData + type: str + + @overload + def __init__( + self, + *, + properties: Optional[MemberCapOverrideProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.computelimit.models.MemberCapOverrideProperties(_Model): + cap: int + provisioning_state: Optional[Union[str, ResourceProvisioningState]] + + @overload + def __init__( + self, + *, + cap: int + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.computelimit.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.computelimit.models.OperationDisplay(_Model): + description: Optional[str] + operation: Optional[str] + provider: Optional[str] + resource: Optional[str] + + + class azure.mgmt.computelimit.models.OperationStatusResult(_Model): + end_time: Optional[datetime] + error: Optional[ErrorDetail] + id: Optional[str] + name: Optional[str] + operations: Optional[list[OperationStatusResult]] + percent_complete: Optional[float] + resource_id: Optional[str] + start_time: Optional[datetime] + status: str + + @overload + def __init__( + self, + *, + end_time: Optional[datetime] = ..., + error: Optional[ErrorDetail] = ..., + id: Optional[str] = ..., + name: Optional[str] = ..., + operations: Optional[list[OperationStatusResult]] = ..., + percent_complete: Optional[float] = ..., + start_time: Optional[datetime] = ..., + status: str + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.computelimit.models.Origin(str, Enum, metaclass=CaseInsensitiveEnumMeta): + SYSTEM = "system" + USER = "user" + USER_SYSTEM = "user,system" + + + class azure.mgmt.computelimit.models.ProxyResource(Resource): + id: str + name: str + system_data: SystemData + type: str + + + class azure.mgmt.computelimit.models.Resource(_Model): + id: Optional[str] + name: Optional[str] + system_data: Optional[SystemData] + type: Optional[str] + + + class azure.mgmt.computelimit.models.ResourceProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CANCELED = "Canceled" + FAILED = "Failed" + SUCCEEDED = "Succeeded" + + + class azure.mgmt.computelimit.models.SetMemberCapOverridesRequest(_Model): + member_cap_overrides: list[MemberCap] + + @overload + def __init__( + self, + *, + member_cap_overrides: list[MemberCap] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.computelimit.models.SetMemberCapOverridesResult(_Model): + member_cap_overrides: list[MemberCap] + + @overload + def __init__( + self, + *, + member_cap_overrides: list[MemberCap] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.computelimit.models.SharedLimit(ProxyResource): + id: str + name: str + properties: Optional[SharedLimitProperties] + system_data: SystemData + type: str + + @overload + def __init__( + self, + *, + properties: Optional[SharedLimitProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.computelimit.models.SharedLimitCap(ProxyResource): + id: str + name: str + properties: Optional[SharedLimitCapProperties] + system_data: SystemData + type: str + + @overload + def __init__( + self, + *, + properties: Optional[SharedLimitCapProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.computelimit.models.SharedLimitCapProperties(_Model): + default_member_cap: Optional[int] + is_bounded_cap: bool + provisioning_state: Optional[Union[str, ResourceProvisioningState]] + + @overload + def __init__( + self, + *, + default_member_cap: Optional[int] = ..., + is_bounded_cap: bool + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.computelimit.models.SharedLimitProperties(_Model): + limit: Optional[int] + provisioning_state: Optional[Union[str, ResourceProvisioningState]] + resource_name: Optional[LimitName] + unit: Optional[str] + + + class azure.mgmt.computelimit.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.computelimit.models.VmFamily(ProxyResource): + id: str + name: str + properties: Optional[VmFamilyProperties] + system_data: SystemData + type: str + + @overload + def __init__( + self, + *, + properties: Optional[VmFamilyProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.computelimit.models.VmFamilyProperties(_Model): + category: Optional[str] + provisioning_state: Optional[Union[str, ResourceProvisioningState]] + + @overload + def __init__( + self, + *, + category: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + +namespace azure.mgmt.computelimit.operations + + class azure.mgmt.computelimit.operations.FeaturesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-04-30', params_added_on={'2026-04-30': ['api_version', 'subscription_id', 'location', 'feature_name', 'accept']}, api_versions_list=['2026-04-30', '2026-06-01', '2026-07-01']) + def begin_disable( + self, + location: str, + feature_name: str, + **kwargs: Any + ) -> LROPoller[OperationStatusResult]: ... + + @overload + def begin_enable( + self, + location: str, + feature_name: str, + body: Optional[FeatureEnableRequest] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[OperationStatusResult]: ... + + @overload + def begin_enable( + self, + location: str, + feature_name: str, + body: Optional[JSON] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[OperationStatusResult]: ... + + @overload + def begin_enable( + self, + location: str, + feature_name: str, + body: Optional[IO[bytes]] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[OperationStatusResult]: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-03-20', params_added_on={'2026-03-20': ['api_version', 'subscription_id', 'location', 'feature_name', 'accept']}, api_versions_list=['2026-03-20', '2026-04-30', '2026-06-01', '2026-07-01']) + def get( + self, + location: str, + feature_name: str, + **kwargs: Any + ) -> Feature: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-03-20', params_added_on={'2026-03-20': ['api_version', 'subscription_id', 'location', 'accept']}, api_versions_list=['2026-03-20', '2026-04-30', '2026-06-01', '2026-07-01']) + def list_by_subscription_location_resource( + self, + location: str, + **kwargs: Any + ) -> ItemPaged[Feature]: ... + + + class azure.mgmt.computelimit.operations.GuestSubscriptionsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def create( + self, + location: str, + guest_subscription_id: str, + resource: GuestSubscription, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> GuestSubscription: ... + + @overload + def create( + self, + location: str, + guest_subscription_id: str, + resource: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> GuestSubscription: ... + + @overload + def create( + self, + location: str, + guest_subscription_id: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> GuestSubscription: ... + + @distributed_trace + def delete( + self, + location: str, + guest_subscription_id: str, + **kwargs: Any + ) -> None: ... + + @distributed_trace + def get( + self, + location: str, + guest_subscription_id: str, + **kwargs: Any + ) -> GuestSubscription: ... + + @distributed_trace + def list_by_subscription_location_resource( + self, + location: str, + **kwargs: Any + ) -> ItemPaged[GuestSubscription]: ... + + + class azure.mgmt.computelimit.operations.MemberCapOverridesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def create_or_update( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + resource: MemberCapOverride, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> MemberCapOverride: ... + + @overload + def create_or_update( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + resource: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> MemberCapOverride: ... + + @overload + def create_or_update( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> MemberCapOverride: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-07-01', params_added_on={'2026-07-01': ['api_version', 'subscription_id', 'location', 'vm_family_name', 'member_subscription_id']}, api_versions_list=['2026-07-01']) + def delete( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + **kwargs: Any + ) -> None: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-07-01', params_added_on={'2026-07-01': ['api_version', 'subscription_id', 'location', 'vm_family_name', 'member_subscription_id', 'accept']}, api_versions_list=['2026-07-01']) + def get( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + **kwargs: Any + ) -> MemberCapOverride: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-07-01', params_added_on={'2026-07-01': ['api_version', 'subscription_id', 'location', 'vm_family_name', 'accept']}, api_versions_list=['2026-07-01']) + def list_by_parent( + self, + location: str, + vm_family_name: str, + **kwargs: Any + ) -> ItemPaged[MemberCapOverride]: ... + + + class azure.mgmt.computelimit.operations.Operations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list(self, **kwargs: Any) -> ItemPaged[Operation]: ... + + + class azure.mgmt.computelimit.operations.SharedLimitCapsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def create_or_update( + self, + location: str, + vm_family_name: str, + resource: SharedLimitCap, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SharedLimitCap: ... + + @overload + def create_or_update( + self, + location: str, + vm_family_name: str, + resource: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SharedLimitCap: ... + + @overload + def create_or_update( + self, + location: str, + vm_family_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SharedLimitCap: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-07-01', params_added_on={'2026-07-01': ['api_version', 'subscription_id', 'location', 'vm_family_name']}, api_versions_list=['2026-07-01']) + def delete( + self, + location: str, + vm_family_name: str, + **kwargs: Any + ) -> None: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-07-01', params_added_on={'2026-07-01': ['api_version', 'subscription_id', 'location', 'vm_family_name', 'accept']}, api_versions_list=['2026-07-01']) + def get( + self, + location: str, + vm_family_name: str, + **kwargs: Any + ) -> SharedLimitCap: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-07-01', params_added_on={'2026-07-01': ['api_version', 'subscription_id', 'location', 'accept']}, api_versions_list=['2026-07-01']) + def list_by_subscription_location_resource( + self, + location: str, + **kwargs: Any + ) -> ItemPaged[SharedLimitCap]: ... + + @overload + def set_member_cap_overrides( + self, + location: str, + vm_family_name: str, + body: SetMemberCapOverridesRequest, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SetMemberCapOverridesResult: ... + + @overload + def set_member_cap_overrides( + self, + location: str, + vm_family_name: str, + body: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SetMemberCapOverridesResult: ... + + @overload + def set_member_cap_overrides( + self, + location: str, + vm_family_name: str, + body: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SetMemberCapOverridesResult: ... + + + class azure.mgmt.computelimit.operations.SharedLimitsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def create( + self, + location: str, + name: str, + resource: SharedLimit, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SharedLimit: ... + + @overload + def create( + self, + location: str, + name: str, + resource: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SharedLimit: ... + + @overload + def create( + self, + location: str, + name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SharedLimit: ... + + @distributed_trace + def delete( + self, + location: str, + name: str, + **kwargs: Any + ) -> None: ... + + @distributed_trace + def get( + self, + location: str, + name: str, + **kwargs: Any + ) -> SharedLimit: ... + + @distributed_trace + def list_by_subscription_location_resource( + self, + location: str, + **kwargs: Any + ) -> ItemPaged[SharedLimit]: ... + + + class azure.mgmt.computelimit.operations.VmFamiliesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-04-30', params_added_on={'2026-04-30': ['api_version', 'subscription_id', 'location', 'vm_family_name', 'accept']}, api_versions_list=['2026-04-30', '2026-06-01', '2026-07-01']) + def get( + self, + location: str, + vm_family_name: str, + **kwargs: Any + ) -> VmFamily: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-04-30', params_added_on={'2026-04-30': ['api_version', 'subscription_id', 'location', 'filter', 'accept']}, api_versions_list=['2026-04-30', '2026-06-01', '2026-07-01']) + def list_by_subscription_location_resource( + self, + location: str, + *, + filter: Optional[str] = ..., + **kwargs: Any + ) -> ItemPaged[VmFamily]: ... + + +``` \ No newline at end of file diff --git a/sdk/computelimit/azure-mgmt-computelimit/api.metadata.yml b/sdk/computelimit/azure-mgmt-computelimit/api.metadata.yml new file mode 100644 index 000000000000..04292e89dd38 --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/api.metadata.yml @@ -0,0 +1,3 @@ +apiMdSha256: 2f646c9516086482d09d0963c173413635c4faf3038ad1ef694ca86ddde9c0b7 +parserVersion: 0.3.28 +pythonVersion: 3.13.13 diff --git a/sdk/computelimit/azure-mgmt-computelimit/apiview-properties.json b/sdk/computelimit/azure-mgmt-computelimit/apiview-properties.json index ce42a042dfde..3d03c48c22e3 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/apiview-properties.json +++ b/sdk/computelimit/azure-mgmt-computelimit/apiview-properties.json @@ -12,10 +12,17 @@ "azure.mgmt.computelimit.models.GuestSubscription": "Microsoft.ComputeLimit.GuestSubscription", "azure.mgmt.computelimit.models.GuestSubscriptionProperties": "Microsoft.ComputeLimit.GuestSubscriptionProperties", "azure.mgmt.computelimit.models.LimitName": "Microsoft.ComputeLimit.LimitName", + "azure.mgmt.computelimit.models.MemberCap": "Microsoft.ComputeLimit.MemberCap", + "azure.mgmt.computelimit.models.MemberCapOverride": "Microsoft.ComputeLimit.MemberCapOverride", + "azure.mgmt.computelimit.models.MemberCapOverrideProperties": "Microsoft.ComputeLimit.MemberCapOverrideProperties", "azure.mgmt.computelimit.models.Operation": "Azure.ResourceManager.CommonTypes.Operation", "azure.mgmt.computelimit.models.OperationDisplay": "Azure.ResourceManager.CommonTypes.OperationDisplay", "azure.mgmt.computelimit.models.OperationStatusResult": "Azure.ResourceManager.CommonTypes.OperationStatusResult", + "azure.mgmt.computelimit.models.SetMemberCapOverridesRequest": "Microsoft.ComputeLimit.SetMemberCapOverridesRequest", + "azure.mgmt.computelimit.models.SetMemberCapOverridesResult": "Microsoft.ComputeLimit.SetMemberCapOverridesResult", "azure.mgmt.computelimit.models.SharedLimit": "Microsoft.ComputeLimit.SharedLimit", + "azure.mgmt.computelimit.models.SharedLimitCap": "Microsoft.ComputeLimit.SharedLimitCap", + "azure.mgmt.computelimit.models.SharedLimitCapProperties": "Microsoft.ComputeLimit.SharedLimitCapProperties", "azure.mgmt.computelimit.models.SharedLimitProperties": "Microsoft.ComputeLimit.SharedLimitProperties", "azure.mgmt.computelimit.models.SystemData": "Azure.ResourceManager.CommonTypes.SystemData", "azure.mgmt.computelimit.models.VmFamily": "Microsoft.ComputeLimit.VmFamily", @@ -54,7 +61,25 @@ "azure.mgmt.computelimit.operations.VmFamiliesOperations.get": "Microsoft.ComputeLimit.VmFamilies.get", "azure.mgmt.computelimit.aio.operations.VmFamiliesOperations.get": "Microsoft.ComputeLimit.VmFamilies.get", "azure.mgmt.computelimit.operations.VmFamiliesOperations.list_by_subscription_location_resource": "Microsoft.ComputeLimit.VmFamilies.listBySubscriptionLocationResource", - "azure.mgmt.computelimit.aio.operations.VmFamiliesOperations.list_by_subscription_location_resource": "Microsoft.ComputeLimit.VmFamilies.listBySubscriptionLocationResource" + "azure.mgmt.computelimit.aio.operations.VmFamiliesOperations.list_by_subscription_location_resource": "Microsoft.ComputeLimit.VmFamilies.listBySubscriptionLocationResource", + "azure.mgmt.computelimit.operations.SharedLimitCapsOperations.get": "Microsoft.ComputeLimit.SharedLimitCaps.get", + "azure.mgmt.computelimit.aio.operations.SharedLimitCapsOperations.get": "Microsoft.ComputeLimit.SharedLimitCaps.get", + "azure.mgmt.computelimit.operations.SharedLimitCapsOperations.create_or_update": "Microsoft.ComputeLimit.SharedLimitCaps.createOrUpdate", + "azure.mgmt.computelimit.aio.operations.SharedLimitCapsOperations.create_or_update": "Microsoft.ComputeLimit.SharedLimitCaps.createOrUpdate", + "azure.mgmt.computelimit.operations.SharedLimitCapsOperations.delete": "Microsoft.ComputeLimit.SharedLimitCaps.delete", + "azure.mgmt.computelimit.aio.operations.SharedLimitCapsOperations.delete": "Microsoft.ComputeLimit.SharedLimitCaps.delete", + "azure.mgmt.computelimit.operations.SharedLimitCapsOperations.list_by_subscription_location_resource": "Microsoft.ComputeLimit.SharedLimitCaps.listBySubscriptionLocationResource", + "azure.mgmt.computelimit.aio.operations.SharedLimitCapsOperations.list_by_subscription_location_resource": "Microsoft.ComputeLimit.SharedLimitCaps.listBySubscriptionLocationResource", + "azure.mgmt.computelimit.operations.SharedLimitCapsOperations.set_member_cap_overrides": "Microsoft.ComputeLimit.SharedLimitCaps.setMemberCapOverrides", + "azure.mgmt.computelimit.aio.operations.SharedLimitCapsOperations.set_member_cap_overrides": "Microsoft.ComputeLimit.SharedLimitCaps.setMemberCapOverrides", + "azure.mgmt.computelimit.operations.MemberCapOverridesOperations.get": "Microsoft.ComputeLimit.MemberCapOverrides.get", + "azure.mgmt.computelimit.aio.operations.MemberCapOverridesOperations.get": "Microsoft.ComputeLimit.MemberCapOverrides.get", + "azure.mgmt.computelimit.operations.MemberCapOverridesOperations.create_or_update": "Microsoft.ComputeLimit.MemberCapOverrides.createOrUpdate", + "azure.mgmt.computelimit.aio.operations.MemberCapOverridesOperations.create_or_update": "Microsoft.ComputeLimit.MemberCapOverrides.createOrUpdate", + "azure.mgmt.computelimit.operations.MemberCapOverridesOperations.delete": "Microsoft.ComputeLimit.MemberCapOverrides.delete", + "azure.mgmt.computelimit.aio.operations.MemberCapOverridesOperations.delete": "Microsoft.ComputeLimit.MemberCapOverrides.delete", + "azure.mgmt.computelimit.operations.MemberCapOverridesOperations.list_by_parent": "Microsoft.ComputeLimit.MemberCapOverrides.listByParent", + "azure.mgmt.computelimit.aio.operations.MemberCapOverridesOperations.list_by_parent": "Microsoft.ComputeLimit.MemberCapOverrides.listByParent" }, - "CrossLanguageVersion": "a2c5e8f9f115" + "CrossLanguageVersion": "716dbef7fdca" } \ No newline at end of file diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_client.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_client.py index c53a87d4ab40..5e9568a738a4 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_client.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_client.py @@ -22,7 +22,9 @@ from .operations import ( FeaturesOperations, GuestSubscriptionsOperations, + MemberCapOverridesOperations, Operations, + SharedLimitCapsOperations, SharedLimitsOperations, VmFamiliesOperations, ) @@ -37,7 +39,7 @@ from azure.core.credentials import TokenCredential -class ComputeLimitMgmtClient: +class ComputeLimitMgmtClient: # pylint: disable=too-many-instance-attributes """Microsoft Azure Compute Limit Resource Provider. :ivar operations: Operations operations @@ -50,6 +52,10 @@ class ComputeLimitMgmtClient: :vartype features: azure.mgmt.computelimit.operations.FeaturesOperations :ivar vm_families: VmFamiliesOperations operations :vartype vm_families: azure.mgmt.computelimit.operations.VmFamiliesOperations + :ivar shared_limit_caps: SharedLimitCapsOperations operations + :vartype shared_limit_caps: azure.mgmt.computelimit.operations.SharedLimitCapsOperations + :ivar member_cap_overrides: MemberCapOverridesOperations operations + :vartype member_cap_overrides: azure.mgmt.computelimit.operations.MemberCapOverridesOperations :param credential: Credential used to authenticate requests to the service. Required. :type credential: ~azure.core.credentials.TokenCredential :param subscription_id: The ID of the target subscription. The value must be an UUID. Required. @@ -59,7 +65,7 @@ class ComputeLimitMgmtClient: :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. Known values are "2026-06-01" + :keyword api_version: The API version to use for this operation. Known values are "2026-07-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 @@ -121,6 +127,12 @@ def __init__( self.shared_limits = SharedLimitsOperations(self._client, self._config, self._serialize, self._deserialize) self.features = FeaturesOperations(self._client, self._config, self._serialize, self._deserialize) self.vm_families = VmFamiliesOperations(self._client, self._config, self._serialize, self._deserialize) + self.shared_limit_caps = SharedLimitCapsOperations( + self._client, self._config, self._serialize, self._deserialize + ) + self.member_cap_overrides = MemberCapOverridesOperations( + self._client, self._config, self._serialize, self._deserialize + ) def send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_configuration.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_configuration.py index 59f26ade59c9..cdc2cdad811c 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_configuration.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_configuration.py @@ -33,7 +33,7 @@ class ComputeLimitMgmtClientConfiguration: # pylint: disable=too-many-instance- :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. Known values are "2026-06-01" + :keyword api_version: The API version to use for this operation. Known values are "2026-07-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", "2026-06-01") + api_version: str = kwargs.pop("api_version", "2026-07-01") if credential is None: raise ValueError("Parameter 'credential' must not be None.") diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_patch.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_patch.py index ea765788358a..87676c65a8f0 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_patch.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_patch.py @@ -8,6 +8,7 @@ Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize """ + __all__: list[str] = [] # Add all objects you want publicly available to users at this package level diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_version.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_version.py index ed0855dea5e6..a73f358d285a 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_version.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "1.1.0" +VERSION = "1.2.0" diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/_client.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/_client.py index a844f7a226a2..ab580e8ce22b 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/_client.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/_client.py @@ -22,7 +22,9 @@ from .operations import ( FeaturesOperations, GuestSubscriptionsOperations, + MemberCapOverridesOperations, Operations, + SharedLimitCapsOperations, SharedLimitsOperations, VmFamiliesOperations, ) @@ -37,7 +39,7 @@ from azure.core.credentials_async import AsyncTokenCredential -class ComputeLimitMgmtClient: +class ComputeLimitMgmtClient: # pylint: disable=too-many-instance-attributes """Microsoft Azure Compute Limit Resource Provider. :ivar operations: Operations operations @@ -51,6 +53,11 @@ class ComputeLimitMgmtClient: :vartype features: azure.mgmt.computelimit.aio.operations.FeaturesOperations :ivar vm_families: VmFamiliesOperations operations :vartype vm_families: azure.mgmt.computelimit.aio.operations.VmFamiliesOperations + :ivar shared_limit_caps: SharedLimitCapsOperations operations + :vartype shared_limit_caps: azure.mgmt.computelimit.aio.operations.SharedLimitCapsOperations + :ivar member_cap_overrides: MemberCapOverridesOperations operations + :vartype member_cap_overrides: + azure.mgmt.computelimit.aio.operations.MemberCapOverridesOperations :param credential: Credential used to authenticate requests to the service. Required. :type credential: ~azure.core.credentials_async.AsyncTokenCredential :param subscription_id: The ID of the target subscription. The value must be an UUID. Required. @@ -60,7 +67,7 @@ class ComputeLimitMgmtClient: :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. Known values are "2026-06-01" + :keyword api_version: The API version to use for this operation. Known values are "2026-07-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 @@ -124,6 +131,12 @@ def __init__( self.shared_limits = SharedLimitsOperations(self._client, self._config, self._serialize, self._deserialize) self.features = FeaturesOperations(self._client, self._config, self._serialize, self._deserialize) self.vm_families = VmFamiliesOperations(self._client, self._config, self._serialize, self._deserialize) + self.shared_limit_caps = SharedLimitCapsOperations( + self._client, self._config, self._serialize, self._deserialize + ) + self.member_cap_overrides = MemberCapOverridesOperations( + self._client, self._config, self._serialize, self._deserialize + ) def send_request( self, request: HttpRequest, *, stream: bool = False, **kwargs: Any diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/_configuration.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/_configuration.py index 020734c7797c..85d59f917fef 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/_configuration.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/_configuration.py @@ -33,7 +33,7 @@ class ComputeLimitMgmtClientConfiguration: # pylint: disable=too-many-instance- :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. Known values are "2026-06-01" + :keyword api_version: The API version to use for this operation. Known values are "2026-07-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", "2026-06-01") + api_version: str = kwargs.pop("api_version", "2026-07-01") if credential is None: raise ValueError("Parameter 'credential' must not be None.") diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/_patch.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/_patch.py index ea765788358a..87676c65a8f0 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/_patch.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/_patch.py @@ -8,6 +8,7 @@ Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize """ + __all__: list[str] = [] # Add all objects you want publicly available to users at this package level diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/operations/__init__.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/operations/__init__.py index 6db1fd4f9685..079b92b782dd 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/operations/__init__.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/operations/__init__.py @@ -17,6 +17,8 @@ from ._operations import SharedLimitsOperations # type: ignore from ._operations import FeaturesOperations # type: ignore from ._operations import VmFamiliesOperations # type: ignore +from ._operations import SharedLimitCapsOperations # type: ignore +from ._operations import MemberCapOverridesOperations # type: ignore from ._patch import __all__ as _patch_all from ._patch import * @@ -28,6 +30,8 @@ "SharedLimitsOperations", "FeaturesOperations", "VmFamiliesOperations", + "SharedLimitCapsOperations", + "MemberCapOverridesOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/operations/_operations.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/operations/_operations.py index a44a7ce9f320..6575ffb1882f 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/operations/_operations.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/operations/_operations.py @@ -46,7 +46,16 @@ build_guest_subscriptions_delete_request, build_guest_subscriptions_get_request, build_guest_subscriptions_list_by_subscription_location_resource_request, + build_member_cap_overrides_create_or_update_request, + build_member_cap_overrides_delete_request, + build_member_cap_overrides_get_request, + build_member_cap_overrides_list_by_parent_request, build_operations_list_request, + build_shared_limit_caps_create_or_update_request, + build_shared_limit_caps_delete_request, + build_shared_limit_caps_get_request, + build_shared_limit_caps_list_by_subscription_location_resource_request, + build_shared_limit_caps_set_member_cap_overrides_request, build_shared_limits_create_request, build_shared_limits_delete_request, build_shared_limits_get_request, @@ -994,7 +1003,7 @@ def __init__(self, *args, **kwargs) -> None: @api_version_validation( method_added_on="2026-03-20", params_added_on={"2026-03-20": ["api_version", "subscription_id", "location", "feature_name", "accept"]}, - api_versions_list=["2026-03-20", "2026-04-30", "2026-06-01"], + api_versions_list=["2026-03-20", "2026-04-30", "2026-06-01", "2026-07-01"], ) async def get(self, location: str, feature_name: str, **kwargs: Any) -> _models.Feature: """Gets the properties of a compute limit feature. @@ -1068,7 +1077,7 @@ async def get(self, location: str, feature_name: str, **kwargs: Any) -> _models. @api_version_validation( method_added_on="2026-03-20", params_added_on={"2026-03-20": ["api_version", "subscription_id", "location", "accept"]}, - api_versions_list=["2026-03-20", "2026-04-30", "2026-06-01"], + api_versions_list=["2026-03-20", "2026-04-30", "2026-06-01", "2026-07-01"], ) def list_by_subscription_location_resource(self, location: str, **kwargs: Any) -> AsyncItemPaged["_models.Feature"]: """Lists all compute limit features for the subscription at the specified location. @@ -1170,7 +1179,7 @@ async def get_next(next_link=None): params_added_on={ "2026-06-01": ["api_version", "subscription_id", "location", "feature_name", "content_type", "accept"] }, - api_versions_list=["2026-06-01"], + api_versions_list=["2026-06-01", "2026-07-01"], ) async def _enable_initial( self, @@ -1341,7 +1350,7 @@ async def begin_enable( params_added_on={ "2026-06-01": ["api_version", "subscription_id", "location", "feature_name", "content_type", "accept"] }, - api_versions_list=["2026-06-01"], + api_versions_list=["2026-06-01", "2026-07-01"], ) async def begin_enable( self, @@ -1421,7 +1430,7 @@ def get_long_running_output(pipeline_response): @api_version_validation( method_added_on="2026-04-30", params_added_on={"2026-04-30": ["api_version", "subscription_id", "location", "feature_name", "accept"]}, - api_versions_list=["2026-04-30", "2026-06-01"], + api_versions_list=["2026-04-30", "2026-06-01", "2026-07-01"], ) async def _disable_initial(self, location: str, feature_name: str, **kwargs: Any) -> AsyncIterator[bytes]: error_map: MutableMapping = { @@ -1486,7 +1495,7 @@ async def _disable_initial(self, location: str, feature_name: str, **kwargs: Any @api_version_validation( method_added_on="2026-04-30", params_added_on={"2026-04-30": ["api_version", "subscription_id", "location", "feature_name", "accept"]}, - api_versions_list=["2026-04-30", "2026-06-01"], + api_versions_list=["2026-04-30", "2026-06-01", "2026-07-01"], ) async def begin_disable( self, location: str, feature_name: str, **kwargs: Any @@ -1574,7 +1583,7 @@ def __init__(self, *args, **kwargs) -> None: @api_version_validation( method_added_on="2026-04-30", params_added_on={"2026-04-30": ["api_version", "subscription_id", "location", "vm_family_name", "accept"]}, - api_versions_list=["2026-04-30", "2026-06-01"], + api_versions_list=["2026-04-30", "2026-06-01", "2026-07-01"], ) async def get(self, location: str, vm_family_name: str, **kwargs: Any) -> _models.VmFamily: """Gets the properties of a VM family. @@ -1648,7 +1657,7 @@ async def get(self, location: str, vm_family_name: str, **kwargs: Any) -> _model @api_version_validation( method_added_on="2026-04-30", params_added_on={"2026-04-30": ["api_version", "subscription_id", "location", "filter", "accept"]}, - api_versions_list=["2026-04-30", "2026-06-01"], + api_versions_list=["2026-04-30", "2026-06-01", "2026-07-01"], ) def list_by_subscription_location_resource( self, location: str, *, filter: Optional[str] = None, **kwargs: Any @@ -1751,3 +1760,1086 @@ async def get_next(next_link=None): return pipeline_response return AsyncItemPaged(get_next, extract_data) + + +class SharedLimitCapsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.computelimit.aio.ComputeLimitMgmtClient`'s + :attr:`shared_limit_caps` attribute. + """ + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: ComputeLimitMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace_async + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={"2026-07-01": ["api_version", "subscription_id", "location", "vm_family_name", "accept"]}, + api_versions_list=["2026-07-01"], + ) + async def get(self, location: str, vm_family_name: str, **kwargs: Any) -> _models.SharedLimitCap: + """Gets the shared limit cap configuration for a VM family, as visible to the caller's + subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :return: SharedLimitCap. The SharedLimitCap is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SharedLimitCap + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.SharedLimitCap] = kwargs.pop("cls", None) + + _request = build_shared_limit_caps_get_request( + location=location, + vm_family_name=vm_family_name, + subscription_id=self._config.subscription_id, + api_version=self._config.api_version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), + } + _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 + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize(_models.SharedLimitCap, response.json()) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @overload + async def create_or_update( + self, + location: str, + vm_family_name: str, + resource: _models.SharedLimitCap, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SharedLimitCap: + """Creates or replaces the shared limit cap configuration for a VM family. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param resource: Resource create parameters. Required. + :type resource: ~azure.mgmt.computelimit.models.SharedLimitCap + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: SharedLimitCap. The SharedLimitCap is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SharedLimitCap + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + location: str, + vm_family_name: str, + resource: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SharedLimitCap: + """Creates or replaces the shared limit cap configuration for a VM family. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param resource: Resource create parameters. Required. + :type resource: JSON + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: SharedLimitCap. The SharedLimitCap is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SharedLimitCap + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + location: str, + vm_family_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SharedLimitCap: + """Creates or replaces the shared limit cap configuration for a VM family. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param resource: Resource create parameters. Required. + :type resource: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: SharedLimitCap. The SharedLimitCap is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SharedLimitCap + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={ + "2026-07-01": ["api_version", "subscription_id", "location", "vm_family_name", "content_type", "accept"] + }, + api_versions_list=["2026-07-01"], + ) + async def create_or_update( + self, + location: str, + vm_family_name: str, + resource: Union[_models.SharedLimitCap, JSON, IO[bytes]], + **kwargs: Any + ) -> _models.SharedLimitCap: + """Creates or replaces the shared limit cap configuration for a VM family. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param resource: Resource create parameters. Is one of the following types: SharedLimitCap, + JSON, IO[bytes] Required. + :type resource: ~azure.mgmt.computelimit.models.SharedLimitCap or JSON or IO[bytes] + :return: SharedLimitCap. The SharedLimitCap is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SharedLimitCap + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.SharedLimitCap] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _content = None + if isinstance(resource, (IOBase, bytes)): + _content = resource + else: + _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore + + _request = build_shared_limit_caps_create_or_update_request( + location=location, + vm_family_name=vm_family_name, + subscription_id=self._config.subscription_id, + content_type=content_type, + api_version=self._config.api_version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), + } + _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 + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize(_models.SharedLimitCap, response.json()) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={"2026-07-01": ["api_version", "subscription_id", "location", "vm_family_name"]}, + api_versions_list=["2026-07-01"], + ) + async def delete(self, location: str, vm_family_name: str, **kwargs: Any) -> None: + """Deletes the shared limit cap configuration for a VM family. The caller's subscription is + treated as the host subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_shared_limit_caps_delete_request( + location=location, + vm_family_name=vm_family_name, + subscription_id=self._config.subscription_id, + api_version=self._config.api_version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 204]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if cls: + return cls(pipeline_response, None, {}) # type: ignore + + @distributed_trace + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={"2026-07-01": ["api_version", "subscription_id", "location", "accept"]}, + api_versions_list=["2026-07-01"], + ) + def list_by_subscription_location_resource( + self, location: str, **kwargs: Any + ) -> AsyncItemPaged["_models.SharedLimitCap"]: + """Lists all shared limit cap configurations visible to the caller's subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :return: An iterator like instance of SharedLimitCap + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.computelimit.models.SharedLimitCap] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[List[_models.SharedLimitCap]] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_shared_limit_caps_list_by_subscription_location_resource_request( + location=location, + subscription_id=self._config.subscription_id, + api_version=self._config.api_version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url( + "self._config.base_url", self._config.base_url, "str", skip_quote=True + ), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url( + "self._config.base_url", self._config.base_url, "str", skip_quote=True + ), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + return _request + + async def extract_data(pipeline_response): + deserialized = pipeline_response.http_response.json() + list_of_elem = _deserialize( + List[_models.SharedLimitCap], + deserialized.get("value", []), + ) + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.get("nextLink") or None, AsyncList(list_of_elem) + + async def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return AsyncItemPaged(get_next, extract_data) + + @overload + async def set_member_cap_overrides( + self, + location: str, + vm_family_name: str, + body: _models.SetMemberCapOverridesRequest, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SetMemberCapOverridesResult: + """Replaces the full set of per-member cap overrides for this shared limit cap. The supplied array + becomes the new complete set of overrides; supplying an empty array clears all existing + overrides. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param body: The content of the action request. Required. + :type body: ~azure.mgmt.computelimit.models.SetMemberCapOverridesRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: SetMemberCapOverridesResult. The SetMemberCapOverridesResult is compatible with + MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SetMemberCapOverridesResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def set_member_cap_overrides( + self, location: str, vm_family_name: str, body: JSON, *, content_type: str = "application/json", **kwargs: Any + ) -> _models.SetMemberCapOverridesResult: + """Replaces the full set of per-member cap overrides for this shared limit cap. The supplied array + becomes the new complete set of overrides; supplying an empty array clears all existing + overrides. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param body: The content of the action request. Required. + :type body: JSON + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: SetMemberCapOverridesResult. The SetMemberCapOverridesResult is compatible with + MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SetMemberCapOverridesResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def set_member_cap_overrides( + self, + location: str, + vm_family_name: str, + body: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SetMemberCapOverridesResult: + """Replaces the full set of per-member cap overrides for this shared limit cap. The supplied array + becomes the new complete set of overrides; supplying an empty array clears all existing + overrides. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param body: The content of the action request. Required. + :type body: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: SetMemberCapOverridesResult. The SetMemberCapOverridesResult is compatible with + MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SetMemberCapOverridesResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={ + "2026-07-01": ["api_version", "subscription_id", "location", "vm_family_name", "content_type", "accept"] + }, + api_versions_list=["2026-07-01"], + ) + async def set_member_cap_overrides( + self, + location: str, + vm_family_name: str, + body: Union[_models.SetMemberCapOverridesRequest, JSON, IO[bytes]], + **kwargs: Any + ) -> _models.SetMemberCapOverridesResult: + """Replaces the full set of per-member cap overrides for this shared limit cap. The supplied array + becomes the new complete set of overrides; supplying an empty array clears all existing + overrides. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param body: The content of the action request. Is one of the following types: + SetMemberCapOverridesRequest, JSON, IO[bytes] Required. + :type body: ~azure.mgmt.computelimit.models.SetMemberCapOverridesRequest or JSON or IO[bytes] + :return: SetMemberCapOverridesResult. The SetMemberCapOverridesResult is compatible with + MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SetMemberCapOverridesResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.SetMemberCapOverridesResult] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _content = None + if isinstance(body, (IOBase, bytes)): + _content = body + else: + _content = json.dumps(body, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore + + _request = build_shared_limit_caps_set_member_cap_overrides_request( + location=location, + vm_family_name=vm_family_name, + subscription_id=self._config.subscription_id, + content_type=content_type, + api_version=self._config.api_version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), + } + _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 + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize(_models.SetMemberCapOverridesResult, response.json()) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + +class MemberCapOverridesOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.computelimit.aio.ComputeLimitMgmtClient`'s + :attr:`member_cap_overrides` attribute. + """ + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: ComputeLimitMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace_async + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={ + "2026-07-01": [ + "api_version", + "subscription_id", + "location", + "vm_family_name", + "member_subscription_id", + "accept", + ] + }, + api_versions_list=["2026-07-01"], + ) + async def get( + self, location: str, vm_family_name: str, member_subscription_id: str, **kwargs: Any + ) -> _models.MemberCapOverride: + """Gets the cap override configured for a single member subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param member_subscription_id: The name of the MemberCapOverride. Required. + :type member_subscription_id: str + :return: MemberCapOverride. The MemberCapOverride is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.MemberCapOverride + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.MemberCapOverride] = kwargs.pop("cls", None) + + _request = build_member_cap_overrides_get_request( + location=location, + vm_family_name=vm_family_name, + member_subscription_id=member_subscription_id, + subscription_id=self._config.subscription_id, + api_version=self._config.api_version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), + } + _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 + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize(_models.MemberCapOverride, response.json()) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @overload + async def create_or_update( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + resource: _models.MemberCapOverride, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.MemberCapOverride: + """Creates or replaces the cap override for a single member subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param member_subscription_id: The name of the MemberCapOverride. Required. + :type member_subscription_id: str + :param resource: Resource create parameters. Required. + :type resource: ~azure.mgmt.computelimit.models.MemberCapOverride + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: MemberCapOverride. The MemberCapOverride is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.MemberCapOverride + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + resource: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.MemberCapOverride: + """Creates or replaces the cap override for a single member subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param member_subscription_id: The name of the MemberCapOverride. Required. + :type member_subscription_id: str + :param resource: Resource create parameters. Required. + :type resource: JSON + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: MemberCapOverride. The MemberCapOverride is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.MemberCapOverride + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.MemberCapOverride: + """Creates or replaces the cap override for a single member subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param member_subscription_id: The name of the MemberCapOverride. Required. + :type member_subscription_id: str + :param resource: Resource create parameters. Required. + :type resource: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: MemberCapOverride. The MemberCapOverride is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.MemberCapOverride + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={ + "2026-07-01": [ + "api_version", + "subscription_id", + "location", + "vm_family_name", + "member_subscription_id", + "content_type", + "accept", + ] + }, + api_versions_list=["2026-07-01"], + ) + async def create_or_update( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + resource: Union[_models.MemberCapOverride, JSON, IO[bytes]], + **kwargs: Any + ) -> _models.MemberCapOverride: + """Creates or replaces the cap override for a single member subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param member_subscription_id: The name of the MemberCapOverride. Required. + :type member_subscription_id: str + :param resource: Resource create parameters. Is one of the following types: MemberCapOverride, + JSON, IO[bytes] Required. + :type resource: ~azure.mgmt.computelimit.models.MemberCapOverride or JSON or IO[bytes] + :return: MemberCapOverride. The MemberCapOverride is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.MemberCapOverride + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.MemberCapOverride] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _content = None + if isinstance(resource, (IOBase, bytes)): + _content = resource + else: + _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore + + _request = build_member_cap_overrides_create_or_update_request( + location=location, + vm_family_name=vm_family_name, + member_subscription_id=member_subscription_id, + subscription_id=self._config.subscription_id, + content_type=content_type, + api_version=self._config.api_version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), + } + _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 + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize(_models.MemberCapOverride, response.json()) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={ + "2026-07-01": ["api_version", "subscription_id", "location", "vm_family_name", "member_subscription_id"] + }, + api_versions_list=["2026-07-01"], + ) + async def delete(self, location: str, vm_family_name: str, member_subscription_id: str, **kwargs: Any) -> None: + """Removes the per-member cap override for a member subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param member_subscription_id: The name of the MemberCapOverride. Required. + :type member_subscription_id: str + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_member_cap_overrides_delete_request( + location=location, + vm_family_name=vm_family_name, + member_subscription_id=member_subscription_id, + subscription_id=self._config.subscription_id, + api_version=self._config.api_version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 204]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if cls: + return cls(pipeline_response, None, {}) # type: ignore + + @distributed_trace + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={"2026-07-01": ["api_version", "subscription_id", "location", "vm_family_name", "accept"]}, + api_versions_list=["2026-07-01"], + ) + def list_by_parent( + self, location: str, vm_family_name: str, **kwargs: Any + ) -> AsyncItemPaged["_models.MemberCapOverride"]: + """Lists all per-member cap overrides configured under a SharedLimitCap. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :return: An iterator like instance of MemberCapOverride + :rtype: + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.computelimit.models.MemberCapOverride] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[List[_models.MemberCapOverride]] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_member_cap_overrides_list_by_parent_request( + location=location, + vm_family_name=vm_family_name, + subscription_id=self._config.subscription_id, + api_version=self._config.api_version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url( + "self._config.base_url", self._config.base_url, "str", skip_quote=True + ), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url( + "self._config.base_url", self._config.base_url, "str", skip_quote=True + ), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + return _request + + async def extract_data(pipeline_response): + deserialized = pipeline_response.http_response.json() + list_of_elem = _deserialize( + List[_models.MemberCapOverride], + deserialized.get("value", []), + ) + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.get("nextLink") or None, AsyncList(list_of_elem) + + async def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return AsyncItemPaged(get_next, extract_data) diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/operations/_patch.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/operations/_patch.py index ea765788358a..87676c65a8f0 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/operations/_patch.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/aio/operations/_patch.py @@ -8,6 +8,7 @@ Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize """ + __all__: list[str] = [] # Add all objects you want publicly available to users at this package level diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/models/__init__.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/models/__init__.py index 3ebe88ef9384..53238938206f 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/models/__init__.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/models/__init__.py @@ -23,12 +23,19 @@ GuestSubscription, GuestSubscriptionProperties, LimitName, + MemberCap, + MemberCapOverride, + MemberCapOverrideProperties, Operation, OperationDisplay, OperationStatusResult, ProxyResource, Resource, + SetMemberCapOverridesRequest, + SetMemberCapOverridesResult, SharedLimit, + SharedLimitCap, + SharedLimitCapProperties, SharedLimitProperties, SystemData, VmFamily, @@ -56,12 +63,19 @@ "GuestSubscription", "GuestSubscriptionProperties", "LimitName", + "MemberCap", + "MemberCapOverride", + "MemberCapOverrideProperties", "Operation", "OperationDisplay", "OperationStatusResult", "ProxyResource", "Resource", + "SetMemberCapOverridesRequest", + "SetMemberCapOverridesResult", "SharedLimit", + "SharedLimitCap", + "SharedLimitCapProperties", "SharedLimitProperties", "SystemData", "VmFamily", diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/models/_models.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/models/_models.py index 9b7a241bfc9a..dbe9d4d65919 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/models/_models.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/models/_models.py @@ -333,6 +333,118 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) +class MemberCap(_Model): + """Per-member cap override. Pairs a member subscription with its cap value. + + :ivar subscription_id: The member subscription identifier this cap applies to. Required. + :vartype subscription_id: str + :ivar cap: The cap value in count units for this member subscription. Required. + :vartype cap: int + """ + + subscription_id: str = rest_field(name="subscriptionId", visibility=["read", "create", "update", "delete", "query"]) + """The member subscription identifier this cap applies to. Required.""" + cap: int = rest_field(visibility=["read", "create", "update", "delete", "query"]) + """The cap value in count units for this member subscription. Required.""" + + @overload + def __init__( + self, + *, + subscription_id: str, + cap: int, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class MemberCapOverride(ProxyResource): + """Member cap override as a standalone child resource of ``SharedLimitCap``. Use this resource to + read or modify a single member's cap without resending the entire ``memberCapOverrides`` array + on the parent. + + :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: ~azure.mgmt.computelimit.models.SystemData + :ivar properties: The resource-specific properties for this resource. + :vartype properties: ~azure.mgmt.computelimit.models.MemberCapOverrideProperties + """ + + properties: Optional["_models.MemberCapOverrideProperties"] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) + """The resource-specific properties for this resource.""" + + @overload + def __init__( + self, + *, + properties: Optional["_models.MemberCapOverrideProperties"] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class MemberCapOverrideProperties(_Model): + """Properties of a per-member cap override. + + :ivar cap: The cap value in count units for this member subscription. Required. + :vartype cap: int + :ivar provisioning_state: The provisioning state of the resource. Known values are: + "Succeeded", "Failed", and "Canceled". + :vartype provisioning_state: str or ~azure.mgmt.computelimit.models.ResourceProvisioningState + """ + + cap: int = rest_field(visibility=["read", "create", "update", "delete", "query"]) + """The cap value in count units for this member subscription. Required.""" + provisioning_state: Optional[Union[str, "_models.ResourceProvisioningState"]] = rest_field( + name="provisioningState", visibility=["read"] + ) + """The provisioning state of the resource. Known values are: \"Succeeded\", \"Failed\", and + \"Canceled\".""" + + @overload + def __init__( + self, + *, + cap: int, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + class Operation(_Model): """REST API Operation. @@ -497,6 +609,70 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) +class SetMemberCapOverridesRequest(_Model): + """Request body for the ``setMemberCapOverrides`` action. + + :ivar member_cap_overrides: The full set of per-member cap overrides to persist for this + resource. This call replaces the existing set entirely; supply an empty array (``[]``) to clear + all overrides. Required. + :vartype member_cap_overrides: list[~azure.mgmt.computelimit.models.MemberCap] + """ + + member_cap_overrides: list["_models.MemberCap"] = rest_field( + name="memberCapOverrides", visibility=["read", "create", "update", "delete", "query"] + ) + """The full set of per-member cap overrides to persist for this resource. This call replaces the + existing set entirely; supply an empty array (``[]``) to clear all overrides. Required.""" + + @overload + def __init__( + self, + *, + member_cap_overrides: list["_models.MemberCap"], + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class SetMemberCapOverridesResult(_Model): + """Response body for the ``setMemberCapOverrides`` action. + + :ivar member_cap_overrides: The per-member cap overrides as persisted after the action + completed. Required. + :vartype member_cap_overrides: list[~azure.mgmt.computelimit.models.MemberCap] + """ + + member_cap_overrides: list["_models.MemberCap"] = rest_field( + name="memberCapOverrides", visibility=["read", "create", "update", "delete", "query"] + ) + """The per-member cap overrides as persisted after the action completed. Required.""" + + @overload + def __init__( + self, + *, + member_cap_overrides: list["_models.MemberCap"], + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + class SharedLimit(ProxyResource): """Compute limits shared by the subscription. @@ -538,6 +714,118 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) +class SharedLimitCap(ProxyResource): + """Shared limit cap configuration for a VM family, owned by a host subscription and propagated to + its member subscriptions. The same resource type is readable by host and member subscriptions, + but write operations (PUT/DELETE) are scoped to the caller's subscription as the host. + + :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: ~azure.mgmt.computelimit.models.SystemData + :ivar properties: The resource-specific properties for this resource. + :vartype properties: ~azure.mgmt.computelimit.models.SharedLimitCapProperties + """ + + properties: Optional["_models.SharedLimitCapProperties"] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) + """The resource-specific properties for this resource.""" + + @overload + def __init__( + self, + *, + properties: Optional["_models.SharedLimitCapProperties"] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class SharedLimitCapProperties(_Model): + """Properties of a shared limit cap resource. + + :ivar default_member_cap: The default member cap value (in count units). Set to a non-negative + integer to apply a cap to all member subscriptions that do not have a per-member override. Omit + the property to leave no default cap in effect. + :vartype default_member_cap: int + :ivar is_bounded_cap: Controls whether the service validates the aggregate cap against the + group limit for the VM family. + + SUM(caps) is the sum of all per-member overrides' cap values plus + ``defaultMemberCap`` multiplied by the number of member subscriptions without an override. + + When true, the service rejects any configuration where SUM(caps) + exceeds the group limit. When false, SUM(caps) is permitted to exceed + the group limit. + + Enabling this flag is rejected if the current configuration already breaches the group limit; + reduce caps first, then enable. Required. + :vartype is_bounded_cap: bool + :ivar provisioning_state: The provisioning state of the resource. Known values are: + "Succeeded", "Failed", and "Canceled". + :vartype provisioning_state: str or ~azure.mgmt.computelimit.models.ResourceProvisioningState + """ + + default_member_cap: Optional[int] = rest_field( + name="defaultMemberCap", visibility=["read", "create", "update", "delete", "query"] + ) + """The default member cap value (in count units). Set to a non-negative integer to apply a cap to + all member subscriptions that do not have a per-member override. Omit the property to leave no + default cap in effect.""" + is_bounded_cap: bool = rest_field(name="isBoundedCap", visibility=["read", "create", "update", "delete", "query"]) + """Controls whether the service validates the aggregate cap against the + group limit for the VM family. + + SUM(caps) is the sum of all per-member overrides' cap values plus + ``defaultMemberCap`` multiplied by the number of member subscriptions without an override. + + When true, the service rejects any configuration where SUM(caps) + exceeds the group limit. When false, SUM(caps) is permitted to exceed + the group limit. + + Enabling this flag is rejected if the current configuration already breaches the group limit; + reduce caps first, then enable. Required.""" + provisioning_state: Optional[Union[str, "_models.ResourceProvisioningState"]] = rest_field( + name="provisioningState", visibility=["read"] + ) + """The provisioning state of the resource. Known values are: \"Succeeded\", \"Failed\", and + \"Canceled\".""" + + @overload + def __init__( + self, + *, + is_bounded_cap: bool, + default_member_cap: Optional[int] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + class SharedLimitProperties(_Model): """Properties of the compute shared limit. diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/models/_patch.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/models/_patch.py index ea765788358a..87676c65a8f0 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/models/_patch.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/models/_patch.py @@ -8,6 +8,7 @@ Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize """ + __all__: list[str] = [] # Add all objects you want publicly available to users at this package level diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/operations/__init__.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/operations/__init__.py index 6db1fd4f9685..079b92b782dd 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/operations/__init__.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/operations/__init__.py @@ -17,6 +17,8 @@ from ._operations import SharedLimitsOperations # type: ignore from ._operations import FeaturesOperations # type: ignore from ._operations import VmFamiliesOperations # type: ignore +from ._operations import SharedLimitCapsOperations # type: ignore +from ._operations import MemberCapOverridesOperations # type: ignore from ._patch import __all__ as _patch_all from ._patch import * @@ -28,6 +30,8 @@ "SharedLimitsOperations", "FeaturesOperations", "VmFamiliesOperations", + "SharedLimitCapsOperations", + "MemberCapOverridesOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/operations/_operations.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/operations/_operations.py index 53506b94edb4..b387068ede5a 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/operations/_operations.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/operations/_operations.py @@ -51,7 +51,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", "2026-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -72,7 +72,7 @@ def build_guest_subscriptions_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", "2026-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -101,7 +101,7 @@ def build_guest_subscriptions_create_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", "2026-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -130,7 +130,7 @@ def build_guest_subscriptions_delete_request( ) -> HttpRequest: _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) # Construct URL _url = "/subscriptions/{subscriptionId}/providers/Microsoft.ComputeLimit/locations/{location}/guestSubscriptions/{guestSubscriptionId}" path_format_arguments = { @@ -153,7 +153,7 @@ def build_guest_subscriptions_list_by_subscription_location_resource_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", "2026-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -178,7 +178,7 @@ def build_shared_limits_get_request(location: str, name: str, subscription_id: s _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", "2026-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -205,7 +205,7 @@ def build_shared_limits_create_request(location: str, name: str, subscription_id _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", "2026-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -232,7 +232,7 @@ def build_shared_limits_create_request(location: str, name: str, subscription_id def build_shared_limits_delete_request(location: str, name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) # Construct URL _url = "/subscriptions/{subscriptionId}/providers/Microsoft.ComputeLimit/locations/{location}/sharedLimits/{name}" path_format_arguments = { @@ -255,7 +255,7 @@ def build_shared_limits_list_by_subscription_location_resource_request( # pylin _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", "2026-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -280,7 +280,7 @@ def build_features_get_request(location: str, feature_name: str, subscription_id _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", "2026-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -310,7 +310,7 @@ def build_features_list_by_subscription_location_resource_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", "2026-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -336,7 +336,7 @@ def build_features_enable_request(location: str, feature_name: str, subscription _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", "2026-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -366,7 +366,7 @@ def build_features_disable_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", "2026-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -394,7 +394,7 @@ def build_vm_families_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", "2026-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -422,7 +422,7 @@ def build_vm_families_list_by_subscription_location_resource_request( # pylint: _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", "2026-06-01")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -445,6 +445,257 @@ def build_vm_families_list_by_subscription_location_resource_request( # pylint: return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) +def build_shared_limit_caps_get_request( + location: str, vm_family_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = "/subscriptions/{subscriptionId}/providers/Microsoft.ComputeLimit/locations/{location}/sharedLimitCaps/{vmFamilyName}" + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "vmFamilyName": _SERIALIZER.url("vm_family_name", vm_family_name, "str"), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_shared_limit_caps_create_or_update_request( # pylint: disable=name-too-long + location: str, vm_family_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _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", "2026-07-01")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = "/subscriptions/{subscriptionId}/providers/Microsoft.ComputeLimit/locations/{location}/sharedLimitCaps/{vmFamilyName}" + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "vmFamilyName": _SERIALIZER.url("vm_family_name", vm_family_name, "str"), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_shared_limit_caps_delete_request( + location: str, vm_family_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) + # Construct URL + _url = "/subscriptions/{subscriptionId}/providers/Microsoft.ComputeLimit/locations/{location}/sharedLimitCaps/{vmFamilyName}" + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "vmFamilyName": _SERIALIZER.url("vm_family_name", vm_family_name, "str"), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, **kwargs) + + +def build_shared_limit_caps_list_by_subscription_location_resource_request( # pylint: disable=name-too-long + location: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = "/subscriptions/{subscriptionId}/providers/Microsoft.ComputeLimit/locations/{location}/sharedLimitCaps" + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "location": _SERIALIZER.url("location", location, "str"), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_shared_limit_caps_set_member_cap_overrides_request( # pylint: disable=name-too-long + location: str, vm_family_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _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", "2026-07-01")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = "/subscriptions/{subscriptionId}/providers/Microsoft.ComputeLimit/locations/{location}/sharedLimitCaps/{vmFamilyName}/setMemberCapOverrides" + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "vmFamilyName": _SERIALIZER.url("vm_family_name", vm_family_name, "str"), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_member_cap_overrides_get_request( + location: str, vm_family_name: str, member_subscription_id: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = "/subscriptions/{subscriptionId}/providers/Microsoft.ComputeLimit/locations/{location}/sharedLimitCaps/{vmFamilyName}/memberCapOverrides/{memberSubscriptionId}" + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "vmFamilyName": _SERIALIZER.url("vm_family_name", vm_family_name, "str"), + "memberSubscriptionId": _SERIALIZER.url("member_subscription_id", member_subscription_id, "str"), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_member_cap_overrides_create_or_update_request( # pylint: disable=name-too-long + location: str, vm_family_name: str, member_subscription_id: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _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", "2026-07-01")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = "/subscriptions/{subscriptionId}/providers/Microsoft.ComputeLimit/locations/{location}/sharedLimitCaps/{vmFamilyName}/memberCapOverrides/{memberSubscriptionId}" + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "vmFamilyName": _SERIALIZER.url("vm_family_name", vm_family_name, "str"), + "memberSubscriptionId": _SERIALIZER.url("member_subscription_id", member_subscription_id, "str"), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_member_cap_overrides_delete_request( # pylint: disable=name-too-long + location: str, vm_family_name: str, member_subscription_id: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) + # Construct URL + _url = "/subscriptions/{subscriptionId}/providers/Microsoft.ComputeLimit/locations/{location}/sharedLimitCaps/{vmFamilyName}/memberCapOverrides/{memberSubscriptionId}" + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "vmFamilyName": _SERIALIZER.url("vm_family_name", vm_family_name, "str"), + "memberSubscriptionId": _SERIALIZER.url("member_subscription_id", member_subscription_id, "str"), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, **kwargs) + + +def build_member_cap_overrides_list_by_parent_request( # pylint: disable=name-too-long + location: str, vm_family_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-07-01")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = "/subscriptions/{subscriptionId}/providers/Microsoft.ComputeLimit/locations/{location}/sharedLimitCaps/{vmFamilyName}/memberCapOverrides" + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "location": _SERIALIZER.url("location", location, "str"), + "vmFamilyName": _SERIALIZER.url("vm_family_name", vm_family_name, "str"), + } + + _url: str = _url.format(**path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + class Operations: """ .. warning:: @@ -1376,7 +1627,7 @@ def __init__(self, *args, **kwargs) -> None: @api_version_validation( method_added_on="2026-03-20", params_added_on={"2026-03-20": ["api_version", "subscription_id", "location", "feature_name", "accept"]}, - api_versions_list=["2026-03-20", "2026-04-30", "2026-06-01"], + api_versions_list=["2026-03-20", "2026-04-30", "2026-06-01", "2026-07-01"], ) def get(self, location: str, feature_name: str, **kwargs: Any) -> _models.Feature: """Gets the properties of a compute limit feature. @@ -1450,7 +1701,7 @@ def get(self, location: str, feature_name: str, **kwargs: Any) -> _models.Featur @api_version_validation( method_added_on="2026-03-20", params_added_on={"2026-03-20": ["api_version", "subscription_id", "location", "accept"]}, - api_versions_list=["2026-03-20", "2026-04-30", "2026-06-01"], + api_versions_list=["2026-03-20", "2026-04-30", "2026-06-01", "2026-07-01"], ) def list_by_subscription_location_resource(self, location: str, **kwargs: Any) -> ItemPaged["_models.Feature"]: """Lists all compute limit features for the subscription at the specified location. @@ -1552,7 +1803,7 @@ def get_next(next_link=None): params_added_on={ "2026-06-01": ["api_version", "subscription_id", "location", "feature_name", "content_type", "accept"] }, - api_versions_list=["2026-06-01"], + api_versions_list=["2026-06-01", "2026-07-01"], ) def _enable_initial( self, @@ -1720,7 +1971,7 @@ def begin_enable( params_added_on={ "2026-06-01": ["api_version", "subscription_id", "location", "feature_name", "content_type", "accept"] }, - api_versions_list=["2026-06-01"], + api_versions_list=["2026-06-01", "2026-07-01"], ) def begin_enable( self, @@ -1799,7 +2050,7 @@ def get_long_running_output(pipeline_response): @api_version_validation( method_added_on="2026-04-30", params_added_on={"2026-04-30": ["api_version", "subscription_id", "location", "feature_name", "accept"]}, - api_versions_list=["2026-04-30", "2026-06-01"], + api_versions_list=["2026-04-30", "2026-06-01", "2026-07-01"], ) def _disable_initial(self, location: str, feature_name: str, **kwargs: Any) -> Iterator[bytes]: error_map: MutableMapping = { @@ -1864,7 +2115,7 @@ def _disable_initial(self, location: str, feature_name: str, **kwargs: Any) -> I @api_version_validation( method_added_on="2026-04-30", params_added_on={"2026-04-30": ["api_version", "subscription_id", "location", "feature_name", "accept"]}, - api_versions_list=["2026-04-30", "2026-06-01"], + api_versions_list=["2026-04-30", "2026-06-01", "2026-07-01"], ) def begin_disable( self, location: str, feature_name: str, **kwargs: Any @@ -1951,7 +2202,7 @@ def __init__(self, *args, **kwargs) -> None: @api_version_validation( method_added_on="2026-04-30", params_added_on={"2026-04-30": ["api_version", "subscription_id", "location", "vm_family_name", "accept"]}, - api_versions_list=["2026-04-30", "2026-06-01"], + api_versions_list=["2026-04-30", "2026-06-01", "2026-07-01"], ) def get(self, location: str, vm_family_name: str, **kwargs: Any) -> _models.VmFamily: """Gets the properties of a VM family. @@ -2025,7 +2276,7 @@ def get(self, location: str, vm_family_name: str, **kwargs: Any) -> _models.VmFa @api_version_validation( method_added_on="2026-04-30", params_added_on={"2026-04-30": ["api_version", "subscription_id", "location", "filter", "accept"]}, - api_versions_list=["2026-04-30", "2026-06-01"], + api_versions_list=["2026-04-30", "2026-06-01", "2026-07-01"], ) def list_by_subscription_location_resource( self, location: str, *, filter: Optional[str] = None, **kwargs: Any @@ -2128,3 +2379,1089 @@ def get_next(next_link=None): return pipeline_response return ItemPaged(get_next, extract_data) + + +class SharedLimitCapsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.computelimit.ComputeLimitMgmtClient`'s + :attr:`shared_limit_caps` attribute. + """ + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: ComputeLimitMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={"2026-07-01": ["api_version", "subscription_id", "location", "vm_family_name", "accept"]}, + api_versions_list=["2026-07-01"], + ) + def get(self, location: str, vm_family_name: str, **kwargs: Any) -> _models.SharedLimitCap: + """Gets the shared limit cap configuration for a VM family, as visible to the caller's + subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :return: SharedLimitCap. The SharedLimitCap is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SharedLimitCap + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.SharedLimitCap] = kwargs.pop("cls", None) + + _request = build_shared_limit_caps_get_request( + location=location, + vm_family_name=vm_family_name, + subscription_id=self._config.subscription_id, + api_version=self._config.api_version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), + } + _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 + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize(_models.SharedLimitCap, response.json()) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @overload + def create_or_update( + self, + location: str, + vm_family_name: str, + resource: _models.SharedLimitCap, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SharedLimitCap: + """Creates or replaces the shared limit cap configuration for a VM family. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param resource: Resource create parameters. Required. + :type resource: ~azure.mgmt.computelimit.models.SharedLimitCap + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: SharedLimitCap. The SharedLimitCap is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SharedLimitCap + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + location: str, + vm_family_name: str, + resource: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SharedLimitCap: + """Creates or replaces the shared limit cap configuration for a VM family. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param resource: Resource create parameters. Required. + :type resource: JSON + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: SharedLimitCap. The SharedLimitCap is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SharedLimitCap + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + location: str, + vm_family_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SharedLimitCap: + """Creates or replaces the shared limit cap configuration for a VM family. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param resource: Resource create parameters. Required. + :type resource: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: SharedLimitCap. The SharedLimitCap is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SharedLimitCap + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={ + "2026-07-01": ["api_version", "subscription_id", "location", "vm_family_name", "content_type", "accept"] + }, + api_versions_list=["2026-07-01"], + ) + def create_or_update( + self, + location: str, + vm_family_name: str, + resource: Union[_models.SharedLimitCap, JSON, IO[bytes]], + **kwargs: Any + ) -> _models.SharedLimitCap: + """Creates or replaces the shared limit cap configuration for a VM family. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param resource: Resource create parameters. Is one of the following types: SharedLimitCap, + JSON, IO[bytes] Required. + :type resource: ~azure.mgmt.computelimit.models.SharedLimitCap or JSON or IO[bytes] + :return: SharedLimitCap. The SharedLimitCap is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SharedLimitCap + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.SharedLimitCap] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _content = None + if isinstance(resource, (IOBase, bytes)): + _content = resource + else: + _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore + + _request = build_shared_limit_caps_create_or_update_request( + location=location, + vm_family_name=vm_family_name, + subscription_id=self._config.subscription_id, + content_type=content_type, + api_version=self._config.api_version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), + } + _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 + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize(_models.SharedLimitCap, response.json()) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={"2026-07-01": ["api_version", "subscription_id", "location", "vm_family_name"]}, + api_versions_list=["2026-07-01"], + ) + def delete( # pylint: disable=inconsistent-return-statements + self, location: str, vm_family_name: str, **kwargs: Any + ) -> None: + """Deletes the shared limit cap configuration for a VM family. The caller's subscription is + treated as the host subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_shared_limit_caps_delete_request( + location=location, + vm_family_name=vm_family_name, + subscription_id=self._config.subscription_id, + api_version=self._config.api_version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 204]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if cls: + return cls(pipeline_response, None, {}) # type: ignore + + @distributed_trace + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={"2026-07-01": ["api_version", "subscription_id", "location", "accept"]}, + api_versions_list=["2026-07-01"], + ) + def list_by_subscription_location_resource( + self, location: str, **kwargs: Any + ) -> ItemPaged["_models.SharedLimitCap"]: + """Lists all shared limit cap configurations visible to the caller's subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :return: An iterator like instance of SharedLimitCap + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.computelimit.models.SharedLimitCap] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[List[_models.SharedLimitCap]] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_shared_limit_caps_list_by_subscription_location_resource_request( + location=location, + subscription_id=self._config.subscription_id, + api_version=self._config.api_version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url( + "self._config.base_url", self._config.base_url, "str", skip_quote=True + ), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url( + "self._config.base_url", self._config.base_url, "str", skip_quote=True + ), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + return _request + + def extract_data(pipeline_response): + deserialized = pipeline_response.http_response.json() + list_of_elem = _deserialize( + List[_models.SharedLimitCap], + deserialized.get("value", []), + ) + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.get("nextLink") or None, iter(list_of_elem) + + def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return ItemPaged(get_next, extract_data) + + @overload + def set_member_cap_overrides( + self, + location: str, + vm_family_name: str, + body: _models.SetMemberCapOverridesRequest, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SetMemberCapOverridesResult: + """Replaces the full set of per-member cap overrides for this shared limit cap. The supplied array + becomes the new complete set of overrides; supplying an empty array clears all existing + overrides. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param body: The content of the action request. Required. + :type body: ~azure.mgmt.computelimit.models.SetMemberCapOverridesRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: SetMemberCapOverridesResult. The SetMemberCapOverridesResult is compatible with + MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SetMemberCapOverridesResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def set_member_cap_overrides( + self, location: str, vm_family_name: str, body: JSON, *, content_type: str = "application/json", **kwargs: Any + ) -> _models.SetMemberCapOverridesResult: + """Replaces the full set of per-member cap overrides for this shared limit cap. The supplied array + becomes the new complete set of overrides; supplying an empty array clears all existing + overrides. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param body: The content of the action request. Required. + :type body: JSON + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: SetMemberCapOverridesResult. The SetMemberCapOverridesResult is compatible with + MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SetMemberCapOverridesResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def set_member_cap_overrides( + self, + location: str, + vm_family_name: str, + body: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SetMemberCapOverridesResult: + """Replaces the full set of per-member cap overrides for this shared limit cap. The supplied array + becomes the new complete set of overrides; supplying an empty array clears all existing + overrides. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param body: The content of the action request. Required. + :type body: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: SetMemberCapOverridesResult. The SetMemberCapOverridesResult is compatible with + MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SetMemberCapOverridesResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={ + "2026-07-01": ["api_version", "subscription_id", "location", "vm_family_name", "content_type", "accept"] + }, + api_versions_list=["2026-07-01"], + ) + def set_member_cap_overrides( + self, + location: str, + vm_family_name: str, + body: Union[_models.SetMemberCapOverridesRequest, JSON, IO[bytes]], + **kwargs: Any + ) -> _models.SetMemberCapOverridesResult: + """Replaces the full set of per-member cap overrides for this shared limit cap. The supplied array + becomes the new complete set of overrides; supplying an empty array clears all existing + overrides. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param body: The content of the action request. Is one of the following types: + SetMemberCapOverridesRequest, JSON, IO[bytes] Required. + :type body: ~azure.mgmt.computelimit.models.SetMemberCapOverridesRequest or JSON or IO[bytes] + :return: SetMemberCapOverridesResult. The SetMemberCapOverridesResult is compatible with + MutableMapping + :rtype: ~azure.mgmt.computelimit.models.SetMemberCapOverridesResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.SetMemberCapOverridesResult] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _content = None + if isinstance(body, (IOBase, bytes)): + _content = body + else: + _content = json.dumps(body, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore + + _request = build_shared_limit_caps_set_member_cap_overrides_request( + location=location, + vm_family_name=vm_family_name, + subscription_id=self._config.subscription_id, + content_type=content_type, + api_version=self._config.api_version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), + } + _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 + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize(_models.SetMemberCapOverridesResult, response.json()) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + +class MemberCapOverridesOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.computelimit.ComputeLimitMgmtClient`'s + :attr:`member_cap_overrides` attribute. + """ + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: ComputeLimitMgmtClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={ + "2026-07-01": [ + "api_version", + "subscription_id", + "location", + "vm_family_name", + "member_subscription_id", + "accept", + ] + }, + api_versions_list=["2026-07-01"], + ) + def get( + self, location: str, vm_family_name: str, member_subscription_id: str, **kwargs: Any + ) -> _models.MemberCapOverride: + """Gets the cap override configured for a single member subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param member_subscription_id: The name of the MemberCapOverride. Required. + :type member_subscription_id: str + :return: MemberCapOverride. The MemberCapOverride is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.MemberCapOverride + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.MemberCapOverride] = kwargs.pop("cls", None) + + _request = build_member_cap_overrides_get_request( + location=location, + vm_family_name=vm_family_name, + member_subscription_id=member_subscription_id, + subscription_id=self._config.subscription_id, + api_version=self._config.api_version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), + } + _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 + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize(_models.MemberCapOverride, response.json()) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @overload + def create_or_update( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + resource: _models.MemberCapOverride, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.MemberCapOverride: + """Creates or replaces the cap override for a single member subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param member_subscription_id: The name of the MemberCapOverride. Required. + :type member_subscription_id: str + :param resource: Resource create parameters. Required. + :type resource: ~azure.mgmt.computelimit.models.MemberCapOverride + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: MemberCapOverride. The MemberCapOverride is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.MemberCapOverride + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + resource: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.MemberCapOverride: + """Creates or replaces the cap override for a single member subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param member_subscription_id: The name of the MemberCapOverride. Required. + :type member_subscription_id: str + :param resource: Resource create parameters. Required. + :type resource: JSON + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :return: MemberCapOverride. The MemberCapOverride is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.MemberCapOverride + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.MemberCapOverride: + """Creates or replaces the cap override for a single member subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param member_subscription_id: The name of the MemberCapOverride. Required. + :type member_subscription_id: str + :param resource: Resource create parameters. Required. + :type resource: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :return: MemberCapOverride. The MemberCapOverride is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.MemberCapOverride + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={ + "2026-07-01": [ + "api_version", + "subscription_id", + "location", + "vm_family_name", + "member_subscription_id", + "content_type", + "accept", + ] + }, + api_versions_list=["2026-07-01"], + ) + def create_or_update( + self, + location: str, + vm_family_name: str, + member_subscription_id: str, + resource: Union[_models.MemberCapOverride, JSON, IO[bytes]], + **kwargs: Any + ) -> _models.MemberCapOverride: + """Creates or replaces the cap override for a single member subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param member_subscription_id: The name of the MemberCapOverride. Required. + :type member_subscription_id: str + :param resource: Resource create parameters. Is one of the following types: MemberCapOverride, + JSON, IO[bytes] Required. + :type resource: ~azure.mgmt.computelimit.models.MemberCapOverride or JSON or IO[bytes] + :return: MemberCapOverride. The MemberCapOverride is compatible with MutableMapping + :rtype: ~azure.mgmt.computelimit.models.MemberCapOverride + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.MemberCapOverride] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _content = None + if isinstance(resource, (IOBase, bytes)): + _content = resource + else: + _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore + + _request = build_member_cap_overrides_create_or_update_request( + location=location, + vm_family_name=vm_family_name, + member_subscription_id=member_subscription_id, + subscription_id=self._config.subscription_id, + content_type=content_type, + api_version=self._config.api_version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), + } + _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 + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize(_models.MemberCapOverride, response.json()) + + if cls: + return cls(pipeline_response, deserialized, {}) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={ + "2026-07-01": ["api_version", "subscription_id", "location", "vm_family_name", "member_subscription_id"] + }, + api_versions_list=["2026-07-01"], + ) + def delete( # pylint: disable=inconsistent-return-statements + self, location: str, vm_family_name: str, member_subscription_id: str, **kwargs: Any + ) -> None: + """Removes the per-member cap override for a member subscription. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :param member_subscription_id: The name of the MemberCapOverride. Required. + :type member_subscription_id: str + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_member_cap_overrides_delete_request( + location=location, + vm_family_name=vm_family_name, + member_subscription_id=member_subscription_id, + subscription_id=self._config.subscription_id, + api_version=self._config.api_version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 204]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if cls: + return cls(pipeline_response, None, {}) # type: ignore + + @distributed_trace + @api_version_validation( + method_added_on="2026-07-01", + params_added_on={"2026-07-01": ["api_version", "subscription_id", "location", "vm_family_name", "accept"]}, + api_versions_list=["2026-07-01"], + ) + def list_by_parent( + self, location: str, vm_family_name: str, **kwargs: Any + ) -> ItemPaged["_models.MemberCapOverride"]: + """Lists all per-member cap overrides configured under a SharedLimitCap. + + :param location: The name of the Azure region. Required. + :type location: str + :param vm_family_name: The name of the SharedLimitCap. Required. + :type vm_family_name: str + :return: An iterator like instance of MemberCapOverride + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.computelimit.models.MemberCapOverride] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[List[_models.MemberCapOverride]] = kwargs.pop("cls", None) + + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + _request = build_member_cap_overrides_list_by_parent_request( + location=location, + vm_family_name=vm_family_name, + subscription_id=self._config.subscription_id, + api_version=self._config.api_version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url( + "self._config.base_url", self._config.base_url, "str", skip_quote=True + ), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + _request = HttpRequest( + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, + ) + path_format_arguments = { + "endpoint": self._serialize.url( + "self._config.base_url", self._config.base_url, "str", skip_quote=True + ), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + return _request + + def extract_data(pipeline_response): + deserialized = pipeline_response.http_response.json() + list_of_elem = _deserialize( + List[_models.MemberCapOverride], + deserialized.get("value", []), + ) + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.get("nextLink") or None, iter(list_of_elem) + + def get_next(next_link=None): + _request = prepare_request(next_link) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize( + _models.ErrorResponse, + response, + ) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return ItemPaged(get_next, extract_data) diff --git a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/operations/_patch.py b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/operations/_patch.py index ea765788358a..87676c65a8f0 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/operations/_patch.py +++ b/sdk/computelimit/azure-mgmt-computelimit/azure/mgmt/computelimit/operations/_patch.py @@ -8,6 +8,7 @@ Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize """ + __all__: list[str] = [] # Add all objects you want publicly available to users at this package level diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_disable.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_disable.py index 6e50c846bb59..84fa0dcba3af 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_disable.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_disable.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: 2026-06-01/Features_Disable.json +# x-ms-original-file: 2026-07-01/Features_Disable.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_enable.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_enable.py index a99ed5297a6f..2db43378fc65 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_enable.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_enable.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: 2026-06-01/Features_Enable.json +# x-ms-original-file: 2026-07-01/Features_Enable.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_get.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_get.py index 66a95fdcc87b..324d383ba54f 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_get.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_get.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: 2026-06-01/Features_Get.json +# x-ms-original-file: 2026-07-01/Features_Get.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_get_shared_limit.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_get_shared_limit.py index 318169b8616b..267e7e4f2795 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_get_shared_limit.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_get_shared_limit.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: 2026-06-01/Features_Get_SharedLimit.json +# x-ms-original-file: 2026-07-01/Features_Get_SharedLimit.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_list.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_list.py index 544b4906db67..2dce40ea8bc6 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_list.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/features_list.py @@ -37,6 +37,6 @@ def main(): print(item) -# x-ms-original-file: 2026-06-01/Features_List.json +# x-ms-original-file: 2026-07-01/Features_List.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_create.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_create.py index 690f01d5a490..23b18937ed98 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_create.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_create.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-06-01/GuestSubscriptions_Create.json +# x-ms-original-file: 2026-07-01/GuestSubscriptions_Create.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_delete.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_delete.py index 46deb55b1a43..05c530276754 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_delete.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_delete.py @@ -36,6 +36,6 @@ def main(): ) -# x-ms-original-file: 2026-06-01/GuestSubscriptions_Delete.json +# x-ms-original-file: 2026-07-01/GuestSubscriptions_Delete.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_get.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_get.py index d6e3ece04e8e..33131f0fc871 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_get.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_get.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: 2026-06-01/GuestSubscriptions_Get.json +# x-ms-original-file: 2026-07-01/GuestSubscriptions_Get.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_list.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_list.py index e3b759d582df..201108b5ddcf 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_list.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/guest_subscriptions_list.py @@ -37,6 +37,6 @@ def main(): print(item) -# x-ms-original-file: 2026-06-01/GuestSubscriptions_List.json +# x-ms-original-file: 2026-07-01/GuestSubscriptions_List.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/member_cap_overrides_create_or_update.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/member_cap_overrides_create_or_update.py new file mode 100644 index 000000000000..f10701694cb5 --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/member_cap_overrides_create_or_update.py @@ -0,0 +1,44 @@ +# 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 azure.identity import DefaultAzureCredential + +from azure.mgmt.computelimit import ComputeLimitMgmtClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-computelimit +# USAGE + python member_cap_overrides_create_or_update.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = ComputeLimitMgmtClient( + credential=DefaultAzureCredential(), + subscription_id="SUBSCRIPTION_ID", + ) + + response = client.member_cap_overrides.create_or_update( + location="eastus", + vm_family_name="StandardDSv3Family", + member_subscription_id="11111111-1111-1111-1111-111111111111", + resource={"properties": {"cap": 250}}, + ) + print(response) + + +# x-ms-original-file: 2026-07-01/MemberCapOverrides_CreateOrUpdate.json +if __name__ == "__main__": + main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/member_cap_overrides_delete.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/member_cap_overrides_delete.py new file mode 100644 index 000000000000..a3bdc60cdcd0 --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/member_cap_overrides_delete.py @@ -0,0 +1,42 @@ +# 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 azure.identity import DefaultAzureCredential + +from azure.mgmt.computelimit import ComputeLimitMgmtClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-computelimit +# USAGE + python member_cap_overrides_delete.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = ComputeLimitMgmtClient( + credential=DefaultAzureCredential(), + subscription_id="SUBSCRIPTION_ID", + ) + + client.member_cap_overrides.delete( + location="eastus", + vm_family_name="StandardDSv3Family", + member_subscription_id="11111111-1111-1111-1111-111111111111", + ) + + +# x-ms-original-file: 2026-07-01/MemberCapOverrides_Delete.json +if __name__ == "__main__": + main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/member_cap_overrides_get.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/member_cap_overrides_get.py new file mode 100644 index 000000000000..18d3f4e8c393 --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/member_cap_overrides_get.py @@ -0,0 +1,43 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) Python Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from azure.identity import DefaultAzureCredential + +from azure.mgmt.computelimit import ComputeLimitMgmtClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-computelimit +# USAGE + python member_cap_overrides_get.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = ComputeLimitMgmtClient( + credential=DefaultAzureCredential(), + subscription_id="SUBSCRIPTION_ID", + ) + + response = client.member_cap_overrides.get( + location="eastus", + vm_family_name="StandardDSv3Family", + member_subscription_id="11111111-1111-1111-1111-111111111111", + ) + print(response) + + +# x-ms-original-file: 2026-07-01/MemberCapOverrides_Get.json +if __name__ == "__main__": + main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/member_cap_overrides_list_by_parent.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/member_cap_overrides_list_by_parent.py new file mode 100644 index 000000000000..2210b85fd6b2 --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/member_cap_overrides_list_by_parent.py @@ -0,0 +1,43 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) Python Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from azure.identity import DefaultAzureCredential + +from azure.mgmt.computelimit import ComputeLimitMgmtClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-computelimit +# USAGE + python member_cap_overrides_list_by_parent.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = ComputeLimitMgmtClient( + credential=DefaultAzureCredential(), + subscription_id="SUBSCRIPTION_ID", + ) + + response = client.member_cap_overrides.list_by_parent( + location="eastus", + vm_family_name="StandardDSv3Family", + ) + for item in response: + print(item) + + +# x-ms-original-file: 2026-07-01/MemberCapOverrides_ListByParent.json +if __name__ == "__main__": + main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/operations_list.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/operations_list.py index bf3988814a72..ad0f0dfafba1 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/operations_list.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/operations_list.py @@ -35,6 +35,6 @@ def main(): print(item) -# x-ms-original-file: 2026-06-01/Operations_List.json +# x-ms-original-file: 2026-07-01/Operations_List.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_create_or_update.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_create_or_update.py new file mode 100644 index 000000000000..fe9552234839 --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_create_or_update.py @@ -0,0 +1,43 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) Python Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from azure.identity import DefaultAzureCredential + +from azure.mgmt.computelimit import ComputeLimitMgmtClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-computelimit +# USAGE + python shared_limit_caps_create_or_update.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = ComputeLimitMgmtClient( + credential=DefaultAzureCredential(), + subscription_id="SUBSCRIPTION_ID", + ) + + response = client.shared_limit_caps.create_or_update( + location="eastus", + vm_family_name="StandardDSv3Family", + resource={"properties": {"defaultMemberCap": 100, "isBoundedCap": True}}, + ) + print(response) + + +# x-ms-original-file: 2026-07-01/SharedLimitCaps_CreateOrUpdate.json +if __name__ == "__main__": + main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_delete.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_delete.py new file mode 100644 index 000000000000..8fc77affb400 --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_delete.py @@ -0,0 +1,41 @@ +# 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 azure.identity import DefaultAzureCredential + +from azure.mgmt.computelimit import ComputeLimitMgmtClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-computelimit +# USAGE + python shared_limit_caps_delete.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = ComputeLimitMgmtClient( + credential=DefaultAzureCredential(), + subscription_id="SUBSCRIPTION_ID", + ) + + client.shared_limit_caps.delete( + location="eastus", + vm_family_name="StandardDSv3Family", + ) + + +# x-ms-original-file: 2026-07-01/SharedLimitCaps_Delete.json +if __name__ == "__main__": + main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_get.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_get.py new file mode 100644 index 000000000000..0a0eb29e14d7 --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_get.py @@ -0,0 +1,42 @@ +# 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 azure.identity import DefaultAzureCredential + +from azure.mgmt.computelimit import ComputeLimitMgmtClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-computelimit +# USAGE + python shared_limit_caps_get.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = ComputeLimitMgmtClient( + credential=DefaultAzureCredential(), + subscription_id="SUBSCRIPTION_ID", + ) + + response = client.shared_limit_caps.get( + location="eastus", + vm_family_name="StandardDSv3Family", + ) + print(response) + + +# x-ms-original-file: 2026-07-01/SharedLimitCaps_Get.json +if __name__ == "__main__": + main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_list.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_list.py new file mode 100644 index 000000000000..27056543ff8e --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_list.py @@ -0,0 +1,42 @@ +# 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 azure.identity import DefaultAzureCredential + +from azure.mgmt.computelimit import ComputeLimitMgmtClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-computelimit +# USAGE + python shared_limit_caps_list.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = ComputeLimitMgmtClient( + credential=DefaultAzureCredential(), + subscription_id="SUBSCRIPTION_ID", + ) + + response = client.shared_limit_caps.list_by_subscription_location_resource( + location="eastus", + ) + for item in response: + print(item) + + +# x-ms-original-file: 2026-07-01/SharedLimitCaps_List.json +if __name__ == "__main__": + main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_set_member_cap_overrides.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_set_member_cap_overrides.py new file mode 100644 index 000000000000..e38815a20833 --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_set_member_cap_overrides.py @@ -0,0 +1,48 @@ +# 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 azure.identity import DefaultAzureCredential + +from azure.mgmt.computelimit import ComputeLimitMgmtClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-computelimit +# USAGE + python shared_limit_caps_set_member_cap_overrides.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = ComputeLimitMgmtClient( + credential=DefaultAzureCredential(), + subscription_id="SUBSCRIPTION_ID", + ) + + response = client.shared_limit_caps.set_member_cap_overrides( + location="eastus", + vm_family_name="StandardDSv3Family", + body={ + "memberCapOverrides": [ + {"cap": 200, "subscriptionId": "11111111-1111-1111-1111-111111111111"}, + {"cap": 150, "subscriptionId": "22222222-2222-2222-2222-222222222222"}, + ] + }, + ) + print(response) + + +# x-ms-original-file: 2026-07-01/SharedLimitCaps_SetMemberCapOverrides.json +if __name__ == "__main__": + main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_set_member_cap_overrides_clear_all.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_set_member_cap_overrides_clear_all.py new file mode 100644 index 000000000000..1af927de18b3 --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limit_caps_set_member_cap_overrides_clear_all.py @@ -0,0 +1,43 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) Python Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from azure.identity import DefaultAzureCredential + +from azure.mgmt.computelimit import ComputeLimitMgmtClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-computelimit +# USAGE + python shared_limit_caps_set_member_cap_overrides_clear_all.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = ComputeLimitMgmtClient( + credential=DefaultAzureCredential(), + subscription_id="SUBSCRIPTION_ID", + ) + + response = client.shared_limit_caps.set_member_cap_overrides( + location="eastus", + vm_family_name="StandardDSv3Family", + body={"memberCapOverrides": []}, + ) + print(response) + + +# x-ms-original-file: 2026-07-01/SharedLimitCaps_SetMemberCapOverrides_ClearAll.json +if __name__ == "__main__": + main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_create.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_create.py index 2a2a19f95041..6695eba4d2e6 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_create.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_create.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-06-01/SharedLimits_Create.json +# x-ms-original-file: 2026-07-01/SharedLimits_Create.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_delete.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_delete.py index ee7d4aeef447..2484770d9bd3 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_delete.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_delete.py @@ -36,6 +36,6 @@ def main(): ) -# x-ms-original-file: 2026-06-01/SharedLimits_Delete.json +# x-ms-original-file: 2026-07-01/SharedLimits_Delete.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_get.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_get.py index 6ba3e92ae82d..9e7993e1e079 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_get.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_get.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: 2026-06-01/SharedLimits_Get.json +# x-ms-original-file: 2026-07-01/SharedLimits_Get.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_list.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_list.py index 36a45664b735..0576aec30f0a 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_list.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/shared_limits_list.py @@ -37,6 +37,6 @@ def main(): print(item) -# x-ms-original-file: 2026-06-01/SharedLimits_List.json +# x-ms-original-file: 2026-07-01/SharedLimits_List.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/vm_families_get.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/vm_families_get.py index 8c901e1b6d21..0fcdf1236375 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/vm_families_get.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/vm_families_get.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: 2026-06-01/VmFamilies_Get.json +# x-ms-original-file: 2026-07-01/VmFamilies_Get.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/vm_families_list.py b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/vm_families_list.py index e850d03ce022..1654cc7bede0 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/generated_samples/vm_families_list.py +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_samples/vm_families_list.py @@ -37,6 +37,6 @@ def main(): print(item) -# x-ms-original-file: 2026-06-01/VmFamilies_List.json +# x-ms-original-file: 2026-07-01/VmFamilies_List.json if __name__ == "__main__": main() diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_tests/test_compute_limit_mgmt_member_cap_overrides_operations.py b/sdk/computelimit/azure-mgmt-computelimit/generated_tests/test_compute_limit_mgmt_member_cap_overrides_operations.py new file mode 100644 index 000000000000..6410c6dee142 --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_tests/test_compute_limit_mgmt_member_cap_overrides_operations.py @@ -0,0 +1,80 @@ +# 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. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.computelimit import ComputeLimitMgmtClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestComputeLimitMgmtMemberCapOverridesOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(ComputeLimitMgmtClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_member_cap_overrides_get(self, resource_group): + response = self.client.member_cap_overrides.get( + location="str", + vm_family_name="str", + member_subscription_id="str", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_member_cap_overrides_create_or_update(self, resource_group): + response = self.client.member_cap_overrides.create_or_update( + location="str", + vm_family_name="str", + member_subscription_id="str", + resource={ + "id": "str", + "name": "str", + "properties": {"cap": 0, "provisioningState": "str"}, + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "type": "str", + }, + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_member_cap_overrides_delete(self, resource_group): + response = self.client.member_cap_overrides.delete( + location="str", + vm_family_name="str", + member_subscription_id="str", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_member_cap_overrides_list_by_parent(self, resource_group): + response = self.client.member_cap_overrides.list_by_parent( + location="str", + vm_family_name="str", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_tests/test_compute_limit_mgmt_member_cap_overrides_operations_async.py b/sdk/computelimit/azure-mgmt-computelimit/generated_tests/test_compute_limit_mgmt_member_cap_overrides_operations_async.py new file mode 100644 index 000000000000..0d4d05026bda --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_tests/test_compute_limit_mgmt_member_cap_overrides_operations_async.py @@ -0,0 +1,81 @@ +# 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. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.computelimit.aio import ComputeLimitMgmtClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestComputeLimitMgmtMemberCapOverridesOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(ComputeLimitMgmtClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_member_cap_overrides_get(self, resource_group): + response = await self.client.member_cap_overrides.get( + location="str", + vm_family_name="str", + member_subscription_id="str", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_member_cap_overrides_create_or_update(self, resource_group): + response = await self.client.member_cap_overrides.create_or_update( + location="str", + vm_family_name="str", + member_subscription_id="str", + resource={ + "id": "str", + "name": "str", + "properties": {"cap": 0, "provisioningState": "str"}, + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "type": "str", + }, + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_member_cap_overrides_delete(self, resource_group): + response = await self.client.member_cap_overrides.delete( + location="str", + vm_family_name="str", + member_subscription_id="str", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_member_cap_overrides_list_by_parent(self, resource_group): + response = self.client.member_cap_overrides.list_by_parent( + location="str", + vm_family_name="str", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_tests/test_compute_limit_mgmt_shared_limit_caps_operations.py b/sdk/computelimit/azure-mgmt-computelimit/generated_tests/test_compute_limit_mgmt_shared_limit_caps_operations.py new file mode 100644 index 000000000000..7efe663ac75b --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_tests/test_compute_limit_mgmt_shared_limit_caps_operations.py @@ -0,0 +1,88 @@ +# 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. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.computelimit import ComputeLimitMgmtClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestComputeLimitMgmtSharedLimitCapsOperations(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(ComputeLimitMgmtClient) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_shared_limit_caps_get(self, resource_group): + response = self.client.shared_limit_caps.get( + location="str", + vm_family_name="str", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_shared_limit_caps_create_or_update(self, resource_group): + response = self.client.shared_limit_caps.create_or_update( + location="str", + vm_family_name="str", + resource={ + "id": "str", + "name": "str", + "properties": {"isBoundedCap": bool, "defaultMemberCap": 0, "provisioningState": "str"}, + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "type": "str", + }, + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_shared_limit_caps_delete(self, resource_group): + response = self.client.shared_limit_caps.delete( + location="str", + vm_family_name="str", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_shared_limit_caps_list_by_subscription_location_resource(self, resource_group): + response = self.client.shared_limit_caps.list_by_subscription_location_resource( + location="str", + ) + result = [r for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy + def test_shared_limit_caps_set_member_cap_overrides(self, resource_group): + response = self.client.shared_limit_caps.set_member_cap_overrides( + location="str", + vm_family_name="str", + body={"memberCapOverrides": [{"cap": 0, "subscriptionId": "str"}]}, + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/computelimit/azure-mgmt-computelimit/generated_tests/test_compute_limit_mgmt_shared_limit_caps_operations_async.py b/sdk/computelimit/azure-mgmt-computelimit/generated_tests/test_compute_limit_mgmt_shared_limit_caps_operations_async.py new file mode 100644 index 000000000000..de00e1bef63c --- /dev/null +++ b/sdk/computelimit/azure-mgmt-computelimit/generated_tests/test_compute_limit_mgmt_shared_limit_caps_operations_async.py @@ -0,0 +1,89 @@ +# 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. +# -------------------------------------------------------------------------- +import pytest +from azure.mgmt.computelimit.aio import ComputeLimitMgmtClient + +from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer +from devtools_testutils.aio import recorded_by_proxy_async + +AZURE_LOCATION = "eastus" + + +@pytest.mark.skip("you may need to update the auto-generated test case before run it") +class TestComputeLimitMgmtSharedLimitCapsOperationsAsync(AzureMgmtRecordedTestCase): + def setup_method(self, method): + self.client = self.create_mgmt_client(ComputeLimitMgmtClient, is_async=True) + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_shared_limit_caps_get(self, resource_group): + response = await self.client.shared_limit_caps.get( + location="str", + vm_family_name="str", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_shared_limit_caps_create_or_update(self, resource_group): + response = await self.client.shared_limit_caps.create_or_update( + location="str", + vm_family_name="str", + resource={ + "id": "str", + "name": "str", + "properties": {"isBoundedCap": bool, "defaultMemberCap": 0, "provisioningState": "str"}, + "systemData": { + "createdAt": "2020-02-20 00:00:00", + "createdBy": "str", + "createdByType": "str", + "lastModifiedAt": "2020-02-20 00:00:00", + "lastModifiedBy": "str", + "lastModifiedByType": "str", + }, + "type": "str", + }, + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_shared_limit_caps_delete(self, resource_group): + response = await self.client.shared_limit_caps.delete( + location="str", + vm_family_name="str", + ) + + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_shared_limit_caps_list_by_subscription_location_resource(self, resource_group): + response = self.client.shared_limit_caps.list_by_subscription_location_resource( + location="str", + ) + result = [r async for r in response] + # please add some check logic here by yourself + # ... + + @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) + @recorded_by_proxy_async + async def test_shared_limit_caps_set_member_cap_overrides(self, resource_group): + response = await self.client.shared_limit_caps.set_member_cap_overrides( + location="str", + vm_family_name="str", + body={"memberCapOverrides": [{"cap": 0, "subscriptionId": "str"}]}, + ) + + # please add some check logic here by yourself + # ... diff --git a/sdk/computelimit/azure-mgmt-computelimit/pyproject.toml b/sdk/computelimit/azure-mgmt-computelimit/pyproject.toml index 6298f73e5509..d8b47fedb187 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/pyproject.toml +++ b/sdk/computelimit/azure-mgmt-computelimit/pyproject.toml @@ -21,6 +21,7 @@ classifiers = [ "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", ] requires-python = ">=3.10" keywords = [ diff --git a/sdk/computelimit/azure-mgmt-computelimit/tsp-location.yaml b/sdk/computelimit/azure-mgmt-computelimit/tsp-location.yaml index 21149cdec28a..668afe859e81 100644 --- a/sdk/computelimit/azure-mgmt-computelimit/tsp-location.yaml +++ b/sdk/computelimit/azure-mgmt-computelimit/tsp-location.yaml @@ -1,4 +1,4 @@ directory: specification/computelimit/resource-manager/Microsoft.ComputeLimit/ComputeLimit -commit: 5376576f4c7cd72c82446ddaab93642c9fad6b6e +commit: 2114bd7b79b2ff5604db83ebd706b81632cb0ea0 repo: Azure/azure-rest-api-specs additionalDirectories: