diff --git a/sdk/batch/azure-mgmt-batch/CHANGELOG.md b/sdk/batch/azure-mgmt-batch/CHANGELOG.md
index 6aaefb249fa5..0aa19dd92740 100644
--- a/sdk/batch/azure-mgmt-batch/CHANGELOG.md
+++ b/sdk/batch/azure-mgmt-batch/CHANGELOG.md
@@ -1,5 +1,45 @@
# Release History
+## 20.0.0 (2026-11-19)
+
+### Features Added
+
+ - Model `PoolProperties` added property `vm_sku_profile`
+ - Model `VirtualMachineConfiguration` added property `hardware_profile`
+ - Model `VirtualMachineConfiguration` added property `placement`
+ - Model `VirtualMachineConfiguration` added property `resiliency_policy`
+ - Added model `DeploymentConfigurationPatch`
+ - Added model `HardwareProfile`
+ - Added model `MaxInstancePercentPerZonePolicy`
+ - Added model `MaxInstancePercentPerZonePolicyPatch`
+ - Added model `Placement`
+ - Added model `PlacementPatch`
+ - Added model `PoolPatch`
+ - Added model `PoolPatchProperties`
+ - Added enum `RequestedComputeNodeDeallocationOption`
+ - Added model `ResiliencyPolicy`
+ - Added model `ResiliencyPolicyPatch`
+ - Added model `TrackedResource`
+ - Added model `VirtualMachineConfigurationPatch`
+ - Added enum `VirtualMachineSkuAllocationStrategy`
+ - Added model `VirtualMachineSkuProfile`
+ - Added model `VirtualMachineSkuProfileVmSize`
+ - Added model `VmSizeProperties`
+ - Added model `ZoneAllocationPolicy`
+ - Added model `ZoneAllocationPolicyPatch`
+ - Added enum `ZonePlacementPolicyType`
+
+### Breaking Changes
+
+ - Python 3.9 is no longer supported. Python 3.10 or later is required.
+ - `FixedScaleSettings.node_deallocation_option` now uses `RequestedComputeNodeDeallocationOption`, which no longer includes `RetainedData`. The service no longer accepts `RetainedData` in resize requests with API version `2026-10-01`.
+ - Deleted or renamed enum value `AuthenticationMode.TASK_AUTHENTICATION_TOKEN`
+ - Method `PoolOperations.update` changed type of its parameter `parameters` from `Pool` to `PoolPatch`
+
+### Other Changes
+
+ - Deleted model `AzureResource` which actually were not used by SDK users
+
## 19.0.0 (2026-02-27)
### Features Added
diff --git a/sdk/batch/azure-mgmt-batch/README.md b/sdk/batch/azure-mgmt-batch/README.md
index b7ca96af2d40..abcdc469c25c 100644
--- a/sdk/batch/azure-mgmt-batch/README.md
+++ b/sdk/batch/azure-mgmt-batch/README.md
@@ -1,7 +1,7 @@
# Microsoft Azure SDK for Python
This is the Microsoft Azure Batch Management Client Library.
-This package has been tested with Python 3.7+.
+This package has been tested with Python 3.10+.
For a more complete view of Azure libraries, see the [azure sdk python release](https://aka.ms/azsdk/python/all).
## _Disclaimer_
@@ -12,7 +12,7 @@ _Azure SDK Python packages support for Python 2.7 has ended 01 January 2022. For
### Prerequisites
-- Python 3.7+ is required to use this package.
+- Python 3.10+ is required to use this package.
- [Azure subscription](https://azure.microsoft.com/free/)
### Install the package
@@ -24,7 +24,7 @@ pip install azure-identity
### Authentication
-By default, [Azure Active Directory](https://aka.ms/awps/aad) token authentication depends on correct configure of 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.
@@ -59,6 +59,3 @@ Code samples for this package can be found at:
If you encounter any bugs or have suggestions, please file an issue in the
[Issues](https://github.com/Azure/azure-sdk-for-python/issues)
section of the project.
-
-
-
diff --git a/sdk/batch/azure-mgmt-batch/_metadata.json b/sdk/batch/azure-mgmt-batch/_metadata.json
index 5dc29e2fec8c..703735eb565b 100644
--- a/sdk/batch/azure-mgmt-batch/_metadata.json
+++ b/sdk/batch/azure-mgmt-batch/_metadata.json
@@ -1,7 +1,11 @@
{
- "apiVersion": "2025-06-01",
- "commit": "ed16e10caee8ef2ab09f321272877d0efbec0d1e",
+ "apiVersion": "2026-10-01",
+ "apiVersions": {
+ "Microsoft.Batch": "2026-10-01"
+ },
+ "commit": "fe03f6284b62c767079c3f750d2e2f6c102dc6c9",
"repository_url": "https://github.com/Azure/azure-rest-api-specs",
"typespec_src": "specification/batch/resource-manager/Microsoft.Batch/Batch",
- "emitterVersion": "0.60.0"
+ "emitterVersion": "0.63.12",
+ "httpClientPythonVersion": "0.40.1"
}
\ No newline at end of file
diff --git a/sdk/batch/azure-mgmt-batch/api.md b/sdk/batch/azure-mgmt-batch/api.md
new file mode 100644
index 000000000000..6bc37c09f739
--- /dev/null
+++ b/sdk/batch/azure-mgmt-batch/api.md
@@ -0,0 +1,5379 @@
+```py
+namespace azure.mgmt.batch
+
+ class azure.mgmt.batch.BatchManagementClient: implements ContextManager
+ application: ApplicationOperations
+ application_package: ApplicationPackageOperations
+ batch_account: BatchAccountOperations
+ location: LocationOperations
+ network_security_perimeter: NetworkSecurityPerimeterOperations
+ operations: Operations
+ pool: PoolOperations
+ private_endpoint_connection: PrivateEndpointConnectionOperations
+ private_link_resource: PrivateLinkResourceOperations
+
+ 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.batch.aio
+
+ class azure.mgmt.batch.aio.BatchManagementClient: implements AsyncContextManager
+ application: ApplicationOperations
+ application_package: ApplicationPackageOperations
+ batch_account: BatchAccountOperations
+ location: LocationOperations
+ network_security_perimeter: NetworkSecurityPerimeterOperations
+ operations: Operations
+ pool: PoolOperations
+ private_endpoint_connection: PrivateEndpointConnectionOperations
+ private_link_resource: PrivateLinkResourceOperations
+
+ 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.batch.aio.operations
+
+ class azure.mgmt.batch.aio.operations.ApplicationOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @overload
+ async def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ parameters: Optional[Application] = None,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> Application: ...
+
+ @overload
+ async def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ parameters: Optional[Application] = None,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> Application: ...
+
+ @overload
+ async def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ parameters: Optional[IO[bytes]] = None,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> Application: ...
+
+ @distributed_trace_async
+ async def delete(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ **kwargs: Any
+ ) -> None: ...
+
+ @distributed_trace_async
+ async def get(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ **kwargs: Any
+ ) -> Application: ...
+
+ @distributed_trace
+ def list(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ *,
+ maxresults: Optional[int] = ...,
+ **kwargs: Any
+ ) -> AsyncItemPaged[Application]: ...
+
+ @overload
+ async def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ parameters: Application,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> Application: ...
+
+ @overload
+ async def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ parameters: Application,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> Application: ...
+
+ @overload
+ async def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> Application: ...
+
+
+ class azure.mgmt.batch.aio.operations.ApplicationPackageOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @overload
+ async def activate(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ parameters: ActivateApplicationPackageParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> ApplicationPackage: ...
+
+ @overload
+ async def activate(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ parameters: ActivateApplicationPackageParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> ApplicationPackage: ...
+
+ @overload
+ async def activate(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> ApplicationPackage: ...
+
+ @overload
+ async def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ parameters: Optional[ApplicationPackage] = None,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> ApplicationPackage: ...
+
+ @overload
+ async def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ parameters: Optional[ApplicationPackage] = None,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> ApplicationPackage: ...
+
+ @overload
+ async def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ parameters: Optional[IO[bytes]] = None,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> ApplicationPackage: ...
+
+ @distributed_trace_async
+ async def delete(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ **kwargs: Any
+ ) -> None: ...
+
+ @distributed_trace_async
+ async def get(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ **kwargs: Any
+ ) -> ApplicationPackage: ...
+
+ @distributed_trace
+ def list(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ *,
+ maxresults: Optional[int] = ...,
+ **kwargs: Any
+ ) -> AsyncItemPaged[ApplicationPackage]: ...
+
+
+ class azure.mgmt.batch.aio.operations.BatchAccountOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @overload
+ async def begin_create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: BatchAccountCreateParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> AsyncLROPoller[BatchAccount]: ...
+
+ @overload
+ async def begin_create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: BatchAccountCreateParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> AsyncLROPoller[BatchAccount]: ...
+
+ @overload
+ async def begin_create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> AsyncLROPoller[BatchAccount]: ...
+
+ @distributed_trace_async
+ async def begin_delete(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ **kwargs: Any
+ ) -> AsyncLROPoller[None]: ...
+
+ @distributed_trace_async
+ async def get(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ **kwargs: Any
+ ) -> BatchAccount: ...
+
+ @distributed_trace_async
+ async def get_detector(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ detector_id: str,
+ **kwargs: Any
+ ) -> DetectorResponse: ...
+
+ @distributed_trace_async
+ async def get_keys(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ **kwargs: Any
+ ) -> BatchAccountKeys: ...
+
+ @distributed_trace
+ def list(self, **kwargs: Any) -> AsyncItemPaged[BatchAccount]: ...
+
+ @distributed_trace
+ def list_by_resource_group(
+ self,
+ resource_group_name: str,
+ **kwargs: Any
+ ) -> AsyncItemPaged[BatchAccount]: ...
+
+ @distributed_trace
+ def list_detectors(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ **kwargs: Any
+ ) -> AsyncItemPaged[DetectorResponse]: ...
+
+ @distributed_trace
+ def list_outbound_network_dependencies_endpoints(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ **kwargs: Any
+ ) -> AsyncItemPaged[OutboundEnvironmentEndpoint]: ...
+
+ @overload
+ async def regenerate_key(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: BatchAccountRegenerateKeyParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> BatchAccountKeys: ...
+
+ @overload
+ async def regenerate_key(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: BatchAccountRegenerateKeyParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> BatchAccountKeys: ...
+
+ @overload
+ async def regenerate_key(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> BatchAccountKeys: ...
+
+ @distributed_trace_async
+ async def synchronize_auto_storage_keys(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ **kwargs: Any
+ ) -> None: ...
+
+ @overload
+ async def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: BatchAccountUpdateParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> BatchAccount: ...
+
+ @overload
+ async def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: BatchAccountUpdateParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> BatchAccount: ...
+
+ @overload
+ async def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> BatchAccount: ...
+
+
+ class azure.mgmt.batch.aio.operations.LocationOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @overload
+ async def check_name_availability(
+ self,
+ location_name: str,
+ parameters: CheckNameAvailabilityParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> CheckNameAvailabilityResult: ...
+
+ @overload
+ async def check_name_availability(
+ self,
+ location_name: str,
+ parameters: CheckNameAvailabilityParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> CheckNameAvailabilityResult: ...
+
+ @overload
+ async def check_name_availability(
+ self,
+ location_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> CheckNameAvailabilityResult: ...
+
+ @distributed_trace_async
+ async def get_quotas(
+ self,
+ location_name: str,
+ **kwargs: Any
+ ) -> BatchLocationQuota: ...
+
+ @distributed_trace
+ def list_supported_virtual_machine_skus(
+ self,
+ location_name: str,
+ *,
+ filter: Optional[str] = ...,
+ maxresults: Optional[int] = ...,
+ **kwargs: Any
+ ) -> AsyncItemPaged[SupportedSku]: ...
+
+
+ class azure.mgmt.batch.aio.operations.NetworkSecurityPerimeterOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @distributed_trace_async
+ async def begin_reconcile_configuration(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ network_security_perimeter_configuration_name: str,
+ **kwargs: Any
+ ) -> AsyncLROPoller[None]: ...
+
+ @distributed_trace_async
+ async def get_configuration(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ network_security_perimeter_configuration_name: str,
+ **kwargs: Any
+ ) -> NetworkSecurityPerimeterConfiguration: ...
+
+ @distributed_trace
+ def list_configurations(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ **kwargs: Any
+ ) -> AsyncItemPaged[NetworkSecurityPerimeterConfiguration]: ...
+
+
+ class azure.mgmt.batch.aio.operations.Operations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @distributed_trace
+ def list(self, **kwargs: Any) -> AsyncItemPaged[Operation]: ...
+
+
+ class azure.mgmt.batch.aio.operations.PoolOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @distributed_trace_async
+ async def begin_delete(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ **kwargs: Any
+ ) -> AsyncLROPoller[None]: ...
+
+ @overload
+ async def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ parameters: Pool,
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @overload
+ async def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ parameters: Pool,
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @overload
+ async def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @distributed_trace_async
+ async def disable_auto_scale(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @distributed_trace_async
+ async def get(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @distributed_trace
+ def list_by_batch_account(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ *,
+ filter: Optional[str] = ...,
+ maxresults: Optional[int] = ...,
+ select: Optional[str] = ...,
+ **kwargs: Any
+ ) -> AsyncItemPaged[Pool]: ...
+
+ @distributed_trace_async
+ async def stop_resize(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @overload
+ async def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ parameters: PoolPatch,
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @overload
+ async def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ parameters: PoolPatch,
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @overload
+ async def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> Pool: ...
+
+
+ class azure.mgmt.batch.aio.operations.PrivateEndpointConnectionOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @distributed_trace_async
+ async def begin_delete(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ private_endpoint_connection_name: str,
+ **kwargs: Any
+ ) -> AsyncLROPoller[None]: ...
+
+ @overload
+ async def begin_update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ private_endpoint_connection_name: str,
+ parameters: PrivateEndpointConnection,
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> AsyncLROPoller[PrivateEndpointConnection]: ...
+
+ @overload
+ async def begin_update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ private_endpoint_connection_name: str,
+ parameters: PrivateEndpointConnection,
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> AsyncLROPoller[PrivateEndpointConnection]: ...
+
+ @overload
+ async def begin_update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ private_endpoint_connection_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> AsyncLROPoller[PrivateEndpointConnection]: ...
+
+ @distributed_trace_async
+ async def get(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ private_endpoint_connection_name: str,
+ **kwargs: Any
+ ) -> PrivateEndpointConnection: ...
+
+ @distributed_trace
+ def list_by_batch_account(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ *,
+ maxresults: Optional[int] = ...,
+ **kwargs: Any
+ ) -> AsyncItemPaged[PrivateEndpointConnection]: ...
+
+
+ class azure.mgmt.batch.aio.operations.PrivateLinkResourceOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @distributed_trace_async
+ async def get(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ private_link_resource_name: str,
+ **kwargs: Any
+ ) -> PrivateLinkResource: ...
+
+ @distributed_trace
+ def list_by_batch_account(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ *,
+ maxresults: Optional[int] = ...,
+ **kwargs: Any
+ ) -> AsyncItemPaged[PrivateLinkResource]: ...
+
+
+namespace azure.mgmt.batch.models
+
+ class azure.mgmt.batch.models.AccessRule(_Model):
+ name: Optional[str]
+ properties: Optional[AccessRuleProperties]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ name: Optional[str] = ...,
+ properties: Optional[AccessRuleProperties] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.AccessRuleDirection(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ INBOUND = "Inbound"
+ OUTBOUND = "Outbound"
+
+
+ class azure.mgmt.batch.models.AccessRuleProperties(_Model):
+ address_prefixes: Optional[list[str]]
+ direction: Optional[Union[str, AccessRuleDirection]]
+ email_addresses: Optional[list[str]]
+ fully_qualified_domain_names: Optional[list[str]]
+ network_security_perimeters: Optional[list[NetworkSecurityPerimeter]]
+ phone_numbers: Optional[list[str]]
+ subscriptions: Optional[list[AccessRulePropertiesSubscription]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ address_prefixes: Optional[list[str]] = ...,
+ direction: Optional[Union[str, AccessRuleDirection]] = ...,
+ email_addresses: Optional[list[str]] = ...,
+ fully_qualified_domain_names: Optional[list[str]] = ...,
+ network_security_perimeters: Optional[list[NetworkSecurityPerimeter]] = ...,
+ phone_numbers: Optional[list[str]] = ...,
+ subscriptions: Optional[list[AccessRulePropertiesSubscription]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.AccessRulePropertiesSubscription(_Model):
+ id: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ id: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.AccountKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ PRIMARY = "Primary"
+ SECONDARY = "Secondary"
+
+
+ class azure.mgmt.batch.models.ActivateApplicationPackageParameters(_Model):
+ format: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ format: str
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.AllocationState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ RESIZING = "Resizing"
+ STEADY = "Steady"
+ STOPPING = "Stopping"
+
+
+ class azure.mgmt.batch.models.Application(ProxyResource):
+ etag: Optional[str]
+ id: str
+ name: str
+ properties: Optional[ApplicationProperties]
+ system_data: SystemData
+ tags: Optional[dict[str, str]]
+ type: str
+
+ def __getattr__(self, name: str) -> Any: ...
+
+ @overload
+ def __init__(
+ self,
+ *,
+ properties: Optional[ApplicationProperties] = ...,
+ tags: Optional[dict[str, str]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+ def __setattr__(
+ self,
+ key: str,
+ value: Any
+ ) -> None: ...
+
+
+ class azure.mgmt.batch.models.ApplicationPackage(ProxyResource):
+ etag: Optional[str]
+ id: str
+ name: str
+ properties: Optional[ApplicationPackageProperties]
+ system_data: SystemData
+ tags: Optional[dict[str, str]]
+ type: str
+
+ def __getattr__(self, name: str) -> Any: ...
+
+ @overload
+ def __init__(
+ self,
+ *,
+ properties: Optional[ApplicationPackageProperties] = ...,
+ tags: Optional[dict[str, str]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+ def __setattr__(
+ self,
+ key: str,
+ value: Any
+ ) -> None: ...
+
+
+ class azure.mgmt.batch.models.ApplicationPackageProperties(_Model):
+ format: Optional[str]
+ last_activation_time: Optional[datetime]
+ state: Optional[Union[str, PackageState]]
+ storage_url: Optional[str]
+ storage_url_expiry: Optional[datetime]
+
+
+ class azure.mgmt.batch.models.ApplicationPackageReference(_Model):
+ id: str
+ version: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ id: str,
+ version: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ApplicationProperties(_Model):
+ allow_updates: Optional[bool]
+ default_version: Optional[str]
+ display_name: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ allow_updates: Optional[bool] = ...,
+ default_version: Optional[str] = ...,
+ display_name: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.AuthenticationMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ AAD = "AAD"
+ SHARED_KEY = "SharedKey"
+
+
+ class azure.mgmt.batch.models.AutoScaleRun(_Model):
+ error: Optional[AutoScaleRunError]
+ evaluation_time: datetime
+ results: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ error: Optional[AutoScaleRunError] = ...,
+ evaluation_time: datetime,
+ results: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.AutoScaleRunError(_Model):
+ code: str
+ details: Optional[list[AutoScaleRunError]]
+ message: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ code: str,
+ details: Optional[list[AutoScaleRunError]] = ...,
+ message: str
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.AutoScaleSettings(_Model):
+ evaluation_interval: Optional[timedelta]
+ formula: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ evaluation_interval: Optional[timedelta] = ...,
+ formula: str
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.AutoStorageAuthenticationMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ BATCH_ACCOUNT_MANAGED_IDENTITY = "BatchAccountManagedIdentity"
+ STORAGE_KEYS = "StorageKeys"
+
+
+ class azure.mgmt.batch.models.AutoStorageBaseProperties(_Model):
+ authentication_mode: Optional[Union[str, AutoStorageAuthenticationMode]]
+ node_identity_reference: Optional[ComputeNodeIdentityReference]
+ storage_account_id: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ authentication_mode: Optional[Union[str, AutoStorageAuthenticationMode]] = ...,
+ node_identity_reference: Optional[ComputeNodeIdentityReference] = ...,
+ storage_account_id: str
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.AutoStorageProperties(AutoStorageBaseProperties):
+ authentication_mode: Union[str, AutoStorageAuthenticationMode]
+ last_key_sync: datetime
+ node_identity_reference: ComputeNodeIdentityReference
+ storage_account_id: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ authentication_mode: Optional[Union[str, AutoStorageAuthenticationMode]] = ...,
+ last_key_sync: datetime,
+ node_identity_reference: Optional[ComputeNodeIdentityReference] = ...,
+ storage_account_id: str
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.AutoUserScope(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ POOL = "Pool"
+ TASK = "Task"
+
+
+ class azure.mgmt.batch.models.AutoUserSpecification(_Model):
+ elevation_level: Optional[Union[str, ElevationLevel]]
+ scope: Optional[Union[str, AutoUserScope]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ elevation_level: Optional[Union[str, ElevationLevel]] = ...,
+ scope: Optional[Union[str, AutoUserScope]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.AutomaticOSUpgradePolicy(_Model):
+ disable_automatic_rollback: Optional[bool]
+ enable_automatic_os_upgrade: Optional[bool]
+ os_rolling_upgrade_deferral: Optional[bool]
+ use_rolling_upgrade_policy: Optional[bool]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ disable_automatic_rollback: Optional[bool] = ...,
+ enable_automatic_os_upgrade: Optional[bool] = ...,
+ os_rolling_upgrade_deferral: Optional[bool] = ...,
+ use_rolling_upgrade_policy: Optional[bool] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.AzureBlobFileSystemConfiguration(_Model):
+ account_key: Optional[str]
+ account_name: str
+ blobfuse_options: Optional[str]
+ container_name: str
+ identity_reference: Optional[ComputeNodeIdentityReference]
+ relative_mount_path: str
+ sas_key: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ account_key: Optional[str] = ...,
+ account_name: str,
+ blobfuse_options: Optional[str] = ...,
+ container_name: str,
+ identity_reference: Optional[ComputeNodeIdentityReference] = ...,
+ relative_mount_path: str,
+ sas_key: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.AzureFileShareConfiguration(_Model):
+ account_key: str
+ account_name: str
+ azure_file_url: str
+ mount_options: Optional[str]
+ relative_mount_path: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ account_key: str,
+ account_name: str,
+ azure_file_url: str,
+ mount_options: Optional[str] = ...,
+ relative_mount_path: str
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.BatchAccount(TrackedResource):
+ id: str
+ identity: Optional[BatchAccountIdentity]
+ location: str
+ name: str
+ properties: Optional[BatchAccountProperties]
+ system_data: SystemData
+ tags: dict[str, str]
+ type: str
+
+ def __getattr__(self, name: str) -> Any: ...
+
+ @overload
+ def __init__(
+ self,
+ *,
+ identity: Optional[BatchAccountIdentity] = ...,
+ location: str,
+ properties: Optional[BatchAccountProperties] = ...,
+ tags: Optional[dict[str, str]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+ def __setattr__(
+ self,
+ key: str,
+ value: Any
+ ) -> None: ...
+
+
+ class azure.mgmt.batch.models.BatchAccountCreateParameters(_Model):
+ identity: Optional[BatchAccountIdentity]
+ location: str
+ properties: Optional[BatchAccountCreateProperties]
+ tags: Optional[dict[str, str]]
+
+ def __getattr__(self, name: str) -> Any: ...
+
+ @overload
+ def __init__(
+ self,
+ *,
+ identity: Optional[BatchAccountIdentity] = ...,
+ location: str,
+ properties: Optional[BatchAccountCreateProperties] = ...,
+ tags: Optional[dict[str, str]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+ def __setattr__(
+ self,
+ key: str,
+ value: Any
+ ) -> None: ...
+
+
+ class azure.mgmt.batch.models.BatchAccountCreateProperties(_Model):
+ allowed_authentication_modes: Optional[list[Union[str, AuthenticationMode]]]
+ auto_storage: Optional[AutoStorageBaseProperties]
+ encryption: Optional[EncryptionProperties]
+ key_vault_reference: Optional[KeyVaultReference]
+ network_profile: Optional[NetworkProfile]
+ pool_allocation_mode: Optional[Union[str, PoolAllocationMode]]
+ public_network_access: Optional[Union[str, PublicNetworkAccessType]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ allowed_authentication_modes: Optional[list[Union[str, AuthenticationMode]]] = ...,
+ auto_storage: Optional[AutoStorageBaseProperties] = ...,
+ encryption: Optional[EncryptionProperties] = ...,
+ key_vault_reference: Optional[KeyVaultReference] = ...,
+ network_profile: Optional[NetworkProfile] = ...,
+ pool_allocation_mode: Optional[Union[str, PoolAllocationMode]] = ...,
+ public_network_access: Optional[Union[str, PublicNetworkAccessType]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.BatchAccountIdentity(_Model):
+ principal_id: Optional[str]
+ tenant_id: Optional[str]
+ type: Union[str, ResourceIdentityType]
+ user_assigned_identities: Optional[dict[str, UserAssignedIdentities]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ type: Union[str, ResourceIdentityType],
+ user_assigned_identities: Optional[dict[str, UserAssignedIdentities]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.BatchAccountKeys(_Model):
+ account_name: Optional[str]
+ primary: Optional[str]
+ secondary: Optional[str]
+
+
+ class azure.mgmt.batch.models.BatchAccountProperties(_Model):
+ account_endpoint: Optional[str]
+ active_job_and_job_schedule_quota: Optional[int]
+ allowed_authentication_modes: Optional[list[Union[str, AuthenticationMode]]]
+ auto_storage: Optional[AutoStorageProperties]
+ dedicated_core_quota: Optional[int]
+ dedicated_core_quota_per_vm_family: Optional[list[VirtualMachineFamilyCoreQuota]]
+ dedicated_core_quota_per_vm_family_enforced: Optional[bool]
+ encryption: Optional[EncryptionProperties]
+ key_vault_reference: Optional[KeyVaultReference]
+ low_priority_core_quota: Optional[int]
+ network_profile: Optional[NetworkProfile]
+ node_management_endpoint: Optional[str]
+ pool_allocation_mode: Optional[Union[str, PoolAllocationMode]]
+ pool_quota: Optional[int]
+ private_endpoint_connections: Optional[list[PrivateEndpointConnection]]
+ provisioning_state: Optional[Union[str, ProvisioningState]]
+ public_network_access: Optional[Union[str, PublicNetworkAccessType]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ network_profile: Optional[NetworkProfile] = ...,
+ public_network_access: Optional[Union[str, PublicNetworkAccessType]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.BatchAccountRegenerateKeyParameters(_Model):
+ key_name: Union[str, AccountKeyType]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ key_name: Union[str, AccountKeyType]
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.BatchAccountUpdateParameters(_Model):
+ identity: Optional[BatchAccountIdentity]
+ properties: Optional[BatchAccountUpdateProperties]
+ tags: Optional[dict[str, str]]
+
+ def __getattr__(self, name: str) -> Any: ...
+
+ @overload
+ def __init__(
+ self,
+ *,
+ identity: Optional[BatchAccountIdentity] = ...,
+ properties: Optional[BatchAccountUpdateProperties] = ...,
+ tags: Optional[dict[str, str]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+ def __setattr__(
+ self,
+ key: str,
+ value: Any
+ ) -> None: ...
+
+
+ class azure.mgmt.batch.models.BatchAccountUpdateProperties(_Model):
+ allowed_authentication_modes: Optional[list[Union[str, AuthenticationMode]]]
+ auto_storage: Optional[AutoStorageBaseProperties]
+ encryption: Optional[EncryptionProperties]
+ network_profile: Optional[NetworkProfile]
+ public_network_access: Optional[Union[str, PublicNetworkAccessType]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ allowed_authentication_modes: Optional[list[Union[str, AuthenticationMode]]] = ...,
+ auto_storage: Optional[AutoStorageBaseProperties] = ...,
+ encryption: Optional[EncryptionProperties] = ...,
+ network_profile: Optional[NetworkProfile] = ...,
+ public_network_access: Optional[Union[str, PublicNetworkAccessType]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.BatchLocationQuota(_Model):
+ account_quota: Optional[int]
+
+
+ class azure.mgmt.batch.models.BatchPoolIdentity(_Model):
+ type: Union[str, PoolIdentityType]
+ user_assigned_identities: Optional[dict[str, UserAssignedIdentities]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ type: Union[str, PoolIdentityType],
+ user_assigned_identities: Optional[dict[str, UserAssignedIdentities]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.CIFSMountConfiguration(_Model):
+ mount_options: Optional[str]
+ password: str
+ relative_mount_path: str
+ source: str
+ user_name: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ mount_options: Optional[str] = ...,
+ password: str,
+ relative_mount_path: str,
+ source: str,
+ user_name: str
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.CachingType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ NONE = "None"
+ READ_ONLY = "ReadOnly"
+ READ_WRITE = "ReadWrite"
+
+
+ class azure.mgmt.batch.models.CheckNameAvailabilityParameters(_Model):
+ name: str
+ type: Union[str, ResourceType]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ name: str,
+ type: Union[str, ResourceType]
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.CheckNameAvailabilityResult(_Model):
+ message: Optional[str]
+ name_available: Optional[bool]
+ reason: Optional[Union[str, NameAvailabilityReason]]
+
+
+ class azure.mgmt.batch.models.CloudError(_Model):
+ error: Optional[CloudErrorBody]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ error: Optional[CloudErrorBody] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.CloudErrorBody(_Model):
+ code: Optional[str]
+ details: Optional[list[CloudErrorBody]]
+ message: Optional[str]
+ target: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ code: Optional[str] = ...,
+ details: Optional[list[CloudErrorBody]] = ...,
+ message: Optional[str] = ...,
+ target: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ComputeNodeDeallocationOption(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ REQUEUE = "Requeue"
+ RETAINED_DATA = "RetainedData"
+ TASK_COMPLETION = "TaskCompletion"
+ TERMINATE = "Terminate"
+
+
+ class azure.mgmt.batch.models.ComputeNodeFillType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ PACK = "Pack"
+ SPREAD = "Spread"
+
+
+ class azure.mgmt.batch.models.ComputeNodeIdentityReference(_Model):
+ resource_id: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ resource_id: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ContainerConfiguration(_Model):
+ container_image_names: Optional[list[str]]
+ container_registries: Optional[list[ContainerRegistry]]
+ type: Union[str, ContainerType]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ container_image_names: Optional[list[str]] = ...,
+ container_registries: Optional[list[ContainerRegistry]] = ...,
+ type: Union[str, ContainerType]
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ContainerHostBatchBindMountEntry(_Model):
+ is_read_only: Optional[bool]
+ source: Optional[Union[str, ContainerHostDataPath]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ is_read_only: Optional[bool] = ...,
+ source: Optional[Union[str, ContainerHostDataPath]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ContainerHostDataPath(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ APPLICATIONS = "Applications"
+ JOB_PREP = "JobPrep"
+ SHARED = "Shared"
+ STARTUP = "Startup"
+ TASK = "Task"
+ VFS_MOUNTS = "VfsMounts"
+
+
+ class azure.mgmt.batch.models.ContainerRegistry(_Model):
+ identity_reference: Optional[ComputeNodeIdentityReference]
+ password: Optional[str]
+ registry_server: Optional[str]
+ user_name: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ identity_reference: Optional[ComputeNodeIdentityReference] = ...,
+ password: Optional[str] = ...,
+ registry_server: Optional[str] = ...,
+ user_name: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ContainerType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ CRI_COMPATIBLE = "CriCompatible"
+ DOCKER_COMPATIBLE = "DockerCompatible"
+
+
+ class azure.mgmt.batch.models.ContainerWorkingDirectory(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ CONTAINER_IMAGE_DEFAULT = "ContainerImageDefault"
+ TASK_WORKING_DIRECTORY = "TaskWorkingDirectory"
+
+
+ class azure.mgmt.batch.models.CreatedByType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ APPLICATION = "Application"
+ KEY = "Key"
+ MANAGED_IDENTITY = "ManagedIdentity"
+ USER = "User"
+
+
+ class azure.mgmt.batch.models.DataDisk(_Model):
+ caching: Optional[Union[str, CachingType]]
+ disk_size_gb: int
+ lun: int
+ managed_disk: Optional[ManagedDisk]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ caching: Optional[Union[str, CachingType]] = ...,
+ disk_size_gb: int,
+ lun: int,
+ managed_disk: Optional[ManagedDisk] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.DeploymentConfiguration(_Model):
+ virtual_machine_configuration: Optional[VirtualMachineConfiguration]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ virtual_machine_configuration: Optional[VirtualMachineConfiguration] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.DeploymentConfigurationPatch(_Model):
+ virtual_machine_configuration: Optional[VirtualMachineConfigurationPatch]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ virtual_machine_configuration: Optional[VirtualMachineConfigurationPatch] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.DetectorResponse(ProxyResource):
+ etag: Optional[str]
+ id: str
+ name: str
+ properties: Optional[DetectorResponseProperties]
+ system_data: SystemData
+ tags: Optional[dict[str, str]]
+ type: str
+
+ def __getattr__(self, name: str) -> Any: ...
+
+ @overload
+ def __init__(
+ self,
+ *,
+ properties: Optional[DetectorResponseProperties] = ...,
+ tags: Optional[dict[str, str]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+ def __setattr__(
+ self,
+ key: str,
+ value: Any
+ ) -> None: ...
+
+
+ class azure.mgmt.batch.models.DetectorResponseProperties(_Model):
+ value: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ value: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.DiffDiskPlacement(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ CACHE_DISK = "CacheDisk"
+
+
+ class azure.mgmt.batch.models.DiffDiskSettings(_Model):
+ placement: Optional[Union[str, DiffDiskPlacement]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ placement: Optional[Union[str, DiffDiskPlacement]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.DiskCustomerManagedKey(_Model):
+ identity_reference: Optional[ComputeNodeIdentityReference]
+ key_url: Optional[str]
+ rotation_to_latest_key_version_enabled: Optional[bool]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ identity_reference: Optional[ComputeNodeIdentityReference] = ...,
+ key_url: Optional[str] = ...,
+ rotation_to_latest_key_version_enabled: Optional[bool] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.DiskEncryptionConfiguration(_Model):
+ customer_managed_key: Optional[DiskCustomerManagedKey]
+ targets: Optional[list[Union[str, DiskEncryptionTarget]]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ customer_managed_key: Optional[DiskCustomerManagedKey] = ...,
+ targets: Optional[list[Union[str, DiskEncryptionTarget]]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.DiskEncryptionSetParameters(_Model):
+ id: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ id: str
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.DiskEncryptionTarget(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ OS_DISK = "OsDisk"
+ TEMPORARY_DISK = "TemporaryDisk"
+
+
+ class azure.mgmt.batch.models.DynamicVNetAssignmentScope(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ JOB = "job"
+ NONE = "none"
+
+
+ class azure.mgmt.batch.models.ElevationLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ ADMIN = "Admin"
+ NON_ADMIN = "NonAdmin"
+
+
+ class azure.mgmt.batch.models.EncryptionProperties(_Model):
+ key_source: Optional[Union[str, KeySource]]
+ key_vault_properties: Optional[KeyVaultProperties]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ key_source: Optional[Union[str, KeySource]] = ...,
+ key_vault_properties: Optional[KeyVaultProperties] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.EndpointAccessDefaultAction(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ ALLOW = "Allow"
+ DENY = "Deny"
+
+
+ class azure.mgmt.batch.models.EndpointAccessProfile(_Model):
+ default_action: Union[str, EndpointAccessDefaultAction]
+ ip_rules: Optional[list[IPRule]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ default_action: Union[str, EndpointAccessDefaultAction],
+ ip_rules: Optional[list[IPRule]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.EndpointDependency(_Model):
+ description: Optional[str]
+ domain_name: Optional[str]
+ endpoint_details: Optional[list[EndpointDetail]]
+
+
+ class azure.mgmt.batch.models.EndpointDetail(_Model):
+ port: Optional[int]
+
+
+ class azure.mgmt.batch.models.EnvironmentSetting(_Model):
+ name: str
+ value: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ name: str,
+ value: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ErrorAdditionalInfo(_Model):
+ info: Optional[Any]
+ type: Optional[str]
+
+
+ class azure.mgmt.batch.models.ErrorDetail(_Model):
+ additional_info: Optional[list[ErrorAdditionalInfo]]
+ code: Optional[str]
+ details: Optional[list[ErrorDetail]]
+ message: Optional[str]
+ target: Optional[str]
+
+
+ class azure.mgmt.batch.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.batch.models.FixedScaleSettings(_Model):
+ node_deallocation_option: Optional[Union[str, RequestedComputeNodeDeallocationOption]]
+ resize_timeout: Optional[timedelta]
+ target_dedicated_nodes: Optional[int]
+ target_low_priority_nodes: Optional[int]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ node_deallocation_option: Optional[Union[str, RequestedComputeNodeDeallocationOption]] = ...,
+ resize_timeout: Optional[timedelta] = ...,
+ target_dedicated_nodes: Optional[int] = ...,
+ target_low_priority_nodes: Optional[int] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.HardwareProfile(_Model):
+ vm_size_properties: Optional[VmSizeProperties]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ vm_size_properties: Optional[VmSizeProperties] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.HostEndpointSettings(_Model):
+ in_vm_access_control_profile_reference_id: Optional[str]
+ mode: Optional[Union[str, HostEndpointSettingsModeTypes]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ in_vm_access_control_profile_reference_id: Optional[str] = ...,
+ mode: Optional[Union[str, HostEndpointSettingsModeTypes]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.HostEndpointSettingsModeTypes(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ AUDIT = "Audit"
+ ENFORCE = "Enforce"
+
+
+ class azure.mgmt.batch.models.IPAddressProvisioningType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ BATCH_MANAGED = "BatchManaged"
+ NO_PUBLIC_IP_ADDRESSES = "NoPublicIPAddresses"
+ USER_MANAGED = "UserManaged"
+
+
+ class azure.mgmt.batch.models.IPFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ I_PV4 = "IPv4"
+ I_PV6 = "IPv6"
+
+
+ class azure.mgmt.batch.models.IPRule(_Model):
+ action: Union[str, IPRuleAction]
+ value: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ action: Union[str, IPRuleAction],
+ value: str
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.IPRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ ALLOW = "Allow"
+
+
+ class azure.mgmt.batch.models.IPTag(_Model):
+ ip_tag_type: Optional[str]
+ tag: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ ip_tag_type: Optional[str] = ...,
+ tag: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ImageReference(_Model):
+ community_gallery_image_id: Optional[str]
+ id: Optional[str]
+ offer: Optional[str]
+ publisher: Optional[str]
+ shared_gallery_image_id: Optional[str]
+ sku: Optional[str]
+ version: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ community_gallery_image_id: Optional[str] = ...,
+ id: Optional[str] = ...,
+ offer: Optional[str] = ...,
+ publisher: Optional[str] = ...,
+ shared_gallery_image_id: Optional[str] = ...,
+ sku: Optional[str] = ...,
+ version: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.InboundEndpointProtocol(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ TCP = "TCP"
+ UDP = "UDP"
+
+
+ class azure.mgmt.batch.models.InboundNatPool(_Model):
+ backend_port: int
+ frontend_port_range_end: int
+ frontend_port_range_start: int
+ name: str
+ network_security_group_rules: Optional[list[NetworkSecurityGroupRule]]
+ protocol: Union[str, InboundEndpointProtocol]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ backend_port: int,
+ frontend_port_range_end: int,
+ frontend_port_range_start: int,
+ name: str,
+ network_security_group_rules: Optional[list[NetworkSecurityGroupRule]] = ...,
+ protocol: Union[str, InboundEndpointProtocol]
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.InterNodeCommunicationState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ DISABLED = "Disabled"
+ ENABLED = "Enabled"
+
+
+ class azure.mgmt.batch.models.IssueType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ CONFIGURATION_PROPAGATION_FAILURE = "ConfigurationPropagationFailure"
+ MISSING_IDENTITY_CONFIGURATION = "MissingIdentityConfiguration"
+ MISSING_PERIMETER_CONFIGURATION = "MissingPerimeterConfiguration"
+ UNKNOWN = "Unknown"
+
+
+ class azure.mgmt.batch.models.JobDefaultOrder(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ CREATION_TIME = "CreationTime"
+ NONE = "None"
+
+
+ class azure.mgmt.batch.models.KeySource(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ MICROSOFT_BATCH = "Microsoft.Batch"
+ MICROSOFT_KEY_VAULT = "Microsoft.KeyVault"
+
+
+ class azure.mgmt.batch.models.KeyVaultProperties(_Model):
+ key_identifier: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ key_identifier: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.KeyVaultReference(_Model):
+ id: str
+ url: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ id: str,
+ url: str
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.LinuxUserConfiguration(_Model):
+ gid: Optional[int]
+ ssh_private_key: Optional[str]
+ uid: Optional[int]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ gid: Optional[int] = ...,
+ ssh_private_key: Optional[str] = ...,
+ uid: Optional[int] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.LoginMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ BATCH = "Batch"
+ INTERACTIVE = "Interactive"
+
+
+ class azure.mgmt.batch.models.ManagedDisk(_Model):
+ disk_encryption_set: Optional[DiskEncryptionSetParameters]
+ security_profile: Optional[VMDiskSecurityProfile]
+ storage_account_type: Optional[Union[str, StorageAccountType]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ disk_encryption_set: Optional[DiskEncryptionSetParameters] = ...,
+ security_profile: Optional[VMDiskSecurityProfile] = ...,
+ storage_account_type: Optional[Union[str, StorageAccountType]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.MaxInstancePercentPerZonePolicy(_Model):
+ enabled: Optional[bool]
+ value: int
+
+ @overload
+ def __init__(
+ self,
+ *,
+ enabled: Optional[bool] = ...,
+ value: int
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.MaxInstancePercentPerZonePolicyPatch(_Model):
+ enabled: Optional[bool]
+ value: Optional[int]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ enabled: Optional[bool] = ...,
+ value: Optional[int] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.MetadataItem(_Model):
+ name: str
+ value: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ name: str,
+ value: str
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.MountConfiguration(_Model):
+ azure_blob_file_system_configuration: Optional[AzureBlobFileSystemConfiguration]
+ azure_file_share_configuration: Optional[AzureFileShareConfiguration]
+ cifs_mount_configuration: Optional[CIFSMountConfiguration]
+ nfs_mount_configuration: Optional[NFSMountConfiguration]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ azure_blob_file_system_configuration: Optional[AzureBlobFileSystemConfiguration] = ...,
+ azure_file_share_configuration: Optional[AzureFileShareConfiguration] = ...,
+ cifs_mount_configuration: Optional[CIFSMountConfiguration] = ...,
+ nfs_mount_configuration: Optional[NFSMountConfiguration] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.NFSMountConfiguration(_Model):
+ mount_options: Optional[str]
+ relative_mount_path: str
+ source: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ mount_options: Optional[str] = ...,
+ relative_mount_path: str,
+ source: str
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.NameAvailabilityReason(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ ALREADY_EXISTS = "AlreadyExists"
+ INVALID = "Invalid"
+
+
+ class azure.mgmt.batch.models.NetworkConfiguration(_Model):
+ dynamic_vnet_assignment_scope: Optional[Union[str, DynamicVNetAssignmentScope]]
+ enable_accelerated_networking: Optional[bool]
+ endpoint_configuration: Optional[PoolEndpointConfiguration]
+ public_ip_address_configuration: Optional[PublicIPAddressConfiguration]
+ subnet_id: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ dynamic_vnet_assignment_scope: Optional[Union[str, DynamicVNetAssignmentScope]] = ...,
+ enable_accelerated_networking: Optional[bool] = ...,
+ endpoint_configuration: Optional[PoolEndpointConfiguration] = ...,
+ public_ip_address_configuration: Optional[PublicIPAddressConfiguration] = ...,
+ subnet_id: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.NetworkProfile(_Model):
+ account_access: Optional[EndpointAccessProfile]
+ node_management_access: Optional[EndpointAccessProfile]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ account_access: Optional[EndpointAccessProfile] = ...,
+ node_management_access: Optional[EndpointAccessProfile] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.NetworkSecurityGroupRule(_Model):
+ access: Union[str, NetworkSecurityGroupRuleAccess]
+ priority: int
+ source_address_prefix: str
+ source_port_ranges: Optional[list[str]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ access: Union[str, NetworkSecurityGroupRuleAccess],
+ priority: int,
+ source_address_prefix: str,
+ source_port_ranges: Optional[list[str]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.NetworkSecurityGroupRuleAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ ALLOW = "Allow"
+ DENY = "Deny"
+
+
+ class azure.mgmt.batch.models.NetworkSecurityPerimeter(_Model):
+ id: Optional[str]
+ location: Optional[str]
+ perimeter_guid: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ id: Optional[str] = ...,
+ location: Optional[str] = ...,
+ perimeter_guid: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.NetworkSecurityPerimeterConfiguration(ProxyResource):
+ id: str
+ name: str
+ properties: Optional[NetworkSecurityPerimeterConfigurationProperties]
+ system_data: SystemData
+ type: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ properties: Optional[NetworkSecurityPerimeterConfigurationProperties] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.NetworkSecurityPerimeterConfigurationProperties(_Model):
+ network_security_perimeter: Optional[NetworkSecurityPerimeter]
+ profile: Optional[NetworkSecurityProfile]
+ provisioning_issues: Optional[list[ProvisioningIssue]]
+ provisioning_state: Optional[Union[str, NetworkSecurityPerimeterConfigurationProvisioningState]]
+ resource_association: Optional[ResourceAssociation]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ network_security_perimeter: Optional[NetworkSecurityPerimeter] = ...,
+ profile: Optional[NetworkSecurityProfile] = ...,
+ resource_association: Optional[ResourceAssociation] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.NetworkSecurityPerimeterConfigurationProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ ACCEPTED = "Accepted"
+ CANCELED = "Canceled"
+ CREATING = "Creating"
+ DELETING = "Deleting"
+ FAILED = "Failed"
+ SUCCEEDED = "Succeeded"
+ UPDATING = "Updating"
+
+
+ class azure.mgmt.batch.models.NetworkSecurityProfile(_Model):
+ access_rules: Optional[list[AccessRule]]
+ access_rules_version: Optional[int]
+ diagnostic_settings_version: Optional[int]
+ enabled_log_categories: Optional[list[str]]
+ name: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ access_rules: Optional[list[AccessRule]] = ...,
+ access_rules_version: Optional[int] = ...,
+ diagnostic_settings_version: Optional[int] = ...,
+ enabled_log_categories: Optional[list[str]] = ...,
+ name: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.NodePlacementConfiguration(_Model):
+ policy: Optional[Union[str, NodePlacementPolicyType]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ policy: Optional[Union[str, NodePlacementPolicyType]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.NodePlacementPolicyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ REGIONAL = "Regional"
+ ZONAL = "Zonal"
+
+
+ class azure.mgmt.batch.models.OSDisk(_Model):
+ caching: Optional[Union[str, CachingType]]
+ disk_size_gb: Optional[int]
+ ephemeral_os_disk_settings: Optional[DiffDiskSettings]
+ managed_disk: Optional[ManagedDisk]
+ write_accelerator_enabled: Optional[bool]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ caching: Optional[Union[str, CachingType]] = ...,
+ disk_size_gb: Optional[int] = ...,
+ ephemeral_os_disk_settings: Optional[DiffDiskSettings] = ...,
+ managed_disk: Optional[ManagedDisk] = ...,
+ write_accelerator_enabled: Optional[bool] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.Operation(_Model):
+ display: Optional[OperationDisplay]
+ is_data_action: Optional[bool]
+ name: Optional[str]
+ origin: Optional[str]
+ properties: Optional[Any]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ display: Optional[OperationDisplay] = ...,
+ is_data_action: Optional[bool] = ...,
+ name: Optional[str] = ...,
+ origin: Optional[str] = ...,
+ properties: Optional[Any] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.OperationDisplay(_Model):
+ description: Optional[str]
+ operation: Optional[str]
+ provider: Optional[str]
+ resource: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ description: Optional[str] = ...,
+ operation: Optional[str] = ...,
+ provider: Optional[str] = ...,
+ resource: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.OutboundEnvironmentEndpoint(_Model):
+ category: Optional[str]
+ endpoints: Optional[list[EndpointDependency]]
+
+
+ class azure.mgmt.batch.models.PackageState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ ACTIVE = "Active"
+ PENDING = "Pending"
+
+
+ class azure.mgmt.batch.models.Placement(_Model):
+ zone_placement_policy: Union[str, ZonePlacementPolicyType]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ zone_placement_policy: Union[str, ZonePlacementPolicyType]
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.PlacementPatch(_Model):
+ zone_placement_policy: Optional[Union[str, ZonePlacementPolicyType]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ zone_placement_policy: Optional[Union[str, ZonePlacementPolicyType]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.Pool(ProxyResource):
+ etag: Optional[str]
+ id: str
+ identity: Optional[BatchPoolIdentity]
+ name: str
+ properties: Optional[PoolProperties]
+ system_data: SystemData
+ tags: Optional[dict[str, str]]
+ type: str
+
+ def __getattr__(self, name: str) -> Any: ...
+
+ @overload
+ def __init__(
+ self,
+ *,
+ identity: Optional[BatchPoolIdentity] = ...,
+ properties: Optional[PoolProperties] = ...,
+ tags: Optional[dict[str, str]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+ def __setattr__(
+ self,
+ key: str,
+ value: Any
+ ) -> None: ...
+
+
+ class azure.mgmt.batch.models.PoolAllocationMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ BATCH_SERVICE = "BatchService"
+ USER_SUBSCRIPTION = "UserSubscription"
+
+
+ class azure.mgmt.batch.models.PoolEndpointConfiguration(_Model):
+ inbound_nat_pools: list[InboundNatPool]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ inbound_nat_pools: list[InboundNatPool]
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.PoolIdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ NONE = "None"
+ USER_ASSIGNED = "UserAssigned"
+
+
+ class azure.mgmt.batch.models.PoolPatch(_Model):
+ etag: Optional[str]
+ id: Optional[str]
+ identity: Optional[BatchPoolIdentity]
+ properties: Optional[PoolPatchProperties]
+ system_data: Optional[SystemData]
+ tags: Optional[dict[str, str]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ identity: Optional[BatchPoolIdentity] = ...,
+ properties: Optional[PoolPatchProperties] = ...,
+ tags: Optional[dict[str, str]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.PoolPatchProperties(_Model):
+ allocation_state: Optional[Union[str, AllocationState]]
+ allocation_state_transition_time: Optional[datetime]
+ application_packages: Optional[list[ApplicationPackageReference]]
+ auto_scale_run: Optional[AutoScaleRun]
+ creation_time: Optional[datetime]
+ current_dedicated_nodes: Optional[int]
+ current_low_priority_nodes: Optional[int]
+ deployment_configuration: Optional[DeploymentConfigurationPatch]
+ display_name: Optional[str]
+ inter_node_communication: Optional[Union[str, InterNodeCommunicationState]]
+ last_modified: Optional[datetime]
+ metadata: Optional[list[MetadataItem]]
+ mount_configuration: Optional[list[MountConfiguration]]
+ network_configuration: Optional[NetworkConfiguration]
+ provisioning_state: Optional[Union[str, PoolProvisioningState]]
+ provisioning_state_transition_time: Optional[datetime]
+ resize_operation_status: Optional[ResizeOperationStatus]
+ scale_settings: Optional[ScaleSettings]
+ start_task: Optional[StartTask]
+ task_scheduling_policy: Optional[TaskSchedulingPolicy]
+ task_slots_per_node: Optional[int]
+ upgrade_policy: Optional[UpgradePolicy]
+ user_accounts: Optional[list[UserAccount]]
+ vm_size: Optional[str]
+ vm_sku_profile: Optional[VirtualMachineSkuProfile]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ application_packages: Optional[list[ApplicationPackageReference]] = ...,
+ deployment_configuration: Optional[DeploymentConfigurationPatch] = ...,
+ display_name: Optional[str] = ...,
+ inter_node_communication: Optional[Union[str, InterNodeCommunicationState]] = ...,
+ metadata: Optional[list[MetadataItem]] = ...,
+ mount_configuration: Optional[list[MountConfiguration]] = ...,
+ network_configuration: Optional[NetworkConfiguration] = ...,
+ scale_settings: Optional[ScaleSettings] = ...,
+ start_task: Optional[StartTask] = ...,
+ task_scheduling_policy: Optional[TaskSchedulingPolicy] = ...,
+ task_slots_per_node: Optional[int] = ...,
+ upgrade_policy: Optional[UpgradePolicy] = ...,
+ user_accounts: Optional[list[UserAccount]] = ...,
+ vm_size: Optional[str] = ...,
+ vm_sku_profile: Optional[VirtualMachineSkuProfile] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.PoolProperties(_Model):
+ allocation_state: Optional[Union[str, AllocationState]]
+ allocation_state_transition_time: Optional[datetime]
+ application_packages: Optional[list[ApplicationPackageReference]]
+ auto_scale_run: Optional[AutoScaleRun]
+ creation_time: Optional[datetime]
+ current_dedicated_nodes: Optional[int]
+ current_low_priority_nodes: Optional[int]
+ deployment_configuration: Optional[DeploymentConfiguration]
+ display_name: Optional[str]
+ inter_node_communication: Optional[Union[str, InterNodeCommunicationState]]
+ last_modified: Optional[datetime]
+ metadata: Optional[list[MetadataItem]]
+ mount_configuration: Optional[list[MountConfiguration]]
+ network_configuration: Optional[NetworkConfiguration]
+ provisioning_state: Optional[Union[str, PoolProvisioningState]]
+ provisioning_state_transition_time: Optional[datetime]
+ resize_operation_status: Optional[ResizeOperationStatus]
+ scale_settings: Optional[ScaleSettings]
+ start_task: Optional[StartTask]
+ task_scheduling_policy: Optional[TaskSchedulingPolicy]
+ task_slots_per_node: Optional[int]
+ upgrade_policy: Optional[UpgradePolicy]
+ user_accounts: Optional[list[UserAccount]]
+ vm_size: Optional[str]
+ vm_sku_profile: Optional[VirtualMachineSkuProfile]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ application_packages: Optional[list[ApplicationPackageReference]] = ...,
+ deployment_configuration: Optional[DeploymentConfiguration] = ...,
+ display_name: Optional[str] = ...,
+ inter_node_communication: Optional[Union[str, InterNodeCommunicationState]] = ...,
+ metadata: Optional[list[MetadataItem]] = ...,
+ mount_configuration: Optional[list[MountConfiguration]] = ...,
+ network_configuration: Optional[NetworkConfiguration] = ...,
+ scale_settings: Optional[ScaleSettings] = ...,
+ start_task: Optional[StartTask] = ...,
+ task_scheduling_policy: Optional[TaskSchedulingPolicy] = ...,
+ task_slots_per_node: Optional[int] = ...,
+ upgrade_policy: Optional[UpgradePolicy] = ...,
+ user_accounts: Optional[list[UserAccount]] = ...,
+ vm_size: Optional[str] = ...,
+ vm_sku_profile: Optional[VirtualMachineSkuProfile] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.PoolProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ DELETING = "Deleting"
+ SUCCEEDED = "Succeeded"
+
+
+ class azure.mgmt.batch.models.PrivateEndpoint(_Model):
+ id: Optional[str]
+
+
+ class azure.mgmt.batch.models.PrivateEndpointConnection(ProxyResource):
+ etag: Optional[str]
+ id: str
+ name: str
+ properties: Optional[PrivateEndpointConnectionProperties]
+ system_data: SystemData
+ tags: Optional[dict[str, str]]
+ type: str
+
+ def __getattr__(self, name: str) -> Any: ...
+
+ @overload
+ def __init__(
+ self,
+ *,
+ properties: Optional[PrivateEndpointConnectionProperties] = ...,
+ tags: Optional[dict[str, str]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+ def __setattr__(
+ self,
+ key: str,
+ value: Any
+ ) -> None: ...
+
+
+ class azure.mgmt.batch.models.PrivateEndpointConnectionProperties(_Model):
+ group_ids: Optional[list[str]]
+ private_endpoint: Optional[PrivateEndpoint]
+ private_link_service_connection_state: Optional[PrivateLinkServiceConnectionState]
+ provisioning_state: Optional[Union[str, PrivateEndpointConnectionProvisioningState]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ private_link_service_connection_state: Optional[PrivateLinkServiceConnectionState] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.PrivateEndpointConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ CANCELLED = "Cancelled"
+ CREATING = "Creating"
+ DELETING = "Deleting"
+ FAILED = "Failed"
+ SUCCEEDED = "Succeeded"
+ UPDATING = "Updating"
+
+
+ class azure.mgmt.batch.models.PrivateLinkResource(ProxyResource):
+ etag: Optional[str]
+ id: str
+ name: str
+ properties: Optional[PrivateLinkResourceProperties]
+ system_data: SystemData
+ tags: Optional[dict[str, str]]
+ type: str
+
+ def __getattr__(self, name: str) -> Any: ...
+
+ @overload
+ def __init__(
+ self,
+ *,
+ properties: Optional[PrivateLinkResourceProperties] = ...,
+ tags: Optional[dict[str, str]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+ def __setattr__(
+ self,
+ key: str,
+ value: Any
+ ) -> None: ...
+
+
+ class azure.mgmt.batch.models.PrivateLinkResourceProperties(_Model):
+ group_id: Optional[str]
+ required_members: Optional[list[str]]
+ required_zone_names: Optional[list[str]]
+
+
+ class azure.mgmt.batch.models.PrivateLinkServiceConnectionState(_Model):
+ actions_required: Optional[str]
+ description: Optional[str]
+ status: Union[str, PrivateLinkServiceConnectionStatus]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ description: Optional[str] = ...,
+ status: Union[str, PrivateLinkServiceConnectionStatus]
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.PrivateLinkServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ APPROVED = "Approved"
+ DISCONNECTED = "Disconnected"
+ PENDING = "Pending"
+ REJECTED = "Rejected"
+
+
+ class azure.mgmt.batch.models.ProvisioningIssue(_Model):
+ name: Optional[str]
+ properties: Optional[ProvisioningIssueProperties]
+
+
+ class azure.mgmt.batch.models.ProvisioningIssueProperties(_Model):
+ description: Optional[str]
+ issue_type: Optional[Union[str, IssueType]]
+ severity: Optional[Union[str, Severity]]
+ suggested_access_rules: Optional[list[AccessRule]]
+ suggested_resource_ids: Optional[list[str]]
+
+
+ class azure.mgmt.batch.models.ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ CANCELLED = "Cancelled"
+ CREATING = "Creating"
+ DELETING = "Deleting"
+ FAILED = "Failed"
+ INVALID = "Invalid"
+ SUCCEEDED = "Succeeded"
+
+
+ class azure.mgmt.batch.models.ProxyAgentSettings(_Model):
+ enabled: Optional[bool]
+ imds: Optional[HostEndpointSettings]
+ wire_server: Optional[HostEndpointSettings]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ enabled: Optional[bool] = ...,
+ imds: Optional[HostEndpointSettings] = ...,
+ wire_server: Optional[HostEndpointSettings] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ProxyResource(Resource):
+ id: str
+ name: str
+ system_data: SystemData
+ type: str
+
+
+ class azure.mgmt.batch.models.PublicIPAddressConfiguration(_Model):
+ ip_address_ids: Optional[list[str]]
+ ip_families: Optional[list[Union[str, IPFamily]]]
+ ip_tags: Optional[list[IPTag]]
+ provision: Optional[Union[str, IPAddressProvisioningType]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ ip_address_ids: Optional[list[str]] = ...,
+ ip_families: Optional[list[Union[str, IPFamily]]] = ...,
+ ip_tags: Optional[list[IPTag]] = ...,
+ provision: Optional[Union[str, IPAddressProvisioningType]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.PublicNetworkAccessType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ DISABLED = "Disabled"
+ ENABLED = "Enabled"
+ SECURED_BY_PERIMETER = "SecuredByPerimeter"
+
+
+ class azure.mgmt.batch.models.RequestedComputeNodeDeallocationOption(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ REQUEUE = "Requeue"
+ TASK_COMPLETION = "TaskCompletion"
+ TERMINATE = "Terminate"
+
+
+ class azure.mgmt.batch.models.ResiliencyPolicy(_Model):
+ zone_allocation_policy: ZoneAllocationPolicy
+
+ @overload
+ def __init__(
+ self,
+ *,
+ zone_allocation_policy: ZoneAllocationPolicy
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ResiliencyPolicyPatch(_Model):
+ zone_allocation_policy: Optional[ZoneAllocationPolicyPatch]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ zone_allocation_policy: Optional[ZoneAllocationPolicyPatch] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ResizeError(_Model):
+ code: str
+ details: Optional[list[ResizeError]]
+ message: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ code: str,
+ details: Optional[list[ResizeError]] = ...,
+ message: str
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ResizeOperationStatus(_Model):
+ errors: Optional[list[ResizeError]]
+ node_deallocation_option: Optional[Union[str, ComputeNodeDeallocationOption]]
+ resize_timeout: Optional[timedelta]
+ start_time: Optional[datetime]
+ target_dedicated_nodes: Optional[int]
+ target_low_priority_nodes: Optional[int]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ errors: Optional[list[ResizeError]] = ...,
+ node_deallocation_option: Optional[Union[str, ComputeNodeDeallocationOption]] = ...,
+ resize_timeout: Optional[timedelta] = ...,
+ start_time: Optional[datetime] = ...,
+ target_dedicated_nodes: Optional[int] = ...,
+ target_low_priority_nodes: Optional[int] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.Resource(_Model):
+ id: Optional[str]
+ name: Optional[str]
+ system_data: Optional[SystemData]
+ type: Optional[str]
+
+
+ class azure.mgmt.batch.models.ResourceAssociation(_Model):
+ access_mode: Optional[Union[str, ResourceAssociationAccessMode]]
+ name: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ access_mode: Optional[Union[str, ResourceAssociationAccessMode]] = ...,
+ name: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ResourceAssociationAccessMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ AUDIT = "Audit"
+ ENFORCED = "Enforced"
+ LEARNING = "Learning"
+
+
+ class azure.mgmt.batch.models.ResourceFile(_Model):
+ auto_storage_container_name: Optional[str]
+ blob_prefix: Optional[str]
+ file_mode: Optional[str]
+ file_path: Optional[str]
+ http_url: Optional[str]
+ identity_reference: Optional[ComputeNodeIdentityReference]
+ storage_container_url: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ auto_storage_container_name: Optional[str] = ...,
+ blob_prefix: Optional[str] = ...,
+ file_mode: Optional[str] = ...,
+ file_path: Optional[str] = ...,
+ http_url: Optional[str] = ...,
+ identity_reference: Optional[ComputeNodeIdentityReference] = ...,
+ storage_container_url: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ResourceIdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ NONE = "None"
+ SYSTEM_ASSIGNED = "SystemAssigned"
+ USER_ASSIGNED = "UserAssigned"
+
+
+ class azure.mgmt.batch.models.ResourceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ MICROSOFT_BATCH_BATCH_ACCOUNTS = "Microsoft.Batch/batchAccounts"
+
+
+ class azure.mgmt.batch.models.RollingUpgradePolicy(_Model):
+ enable_cross_zone_upgrade: Optional[bool]
+ max_batch_instance_percent: Optional[int]
+ max_unhealthy_instance_percent: Optional[int]
+ max_unhealthy_upgraded_instance_percent: Optional[int]
+ pause_time_between_batches: Optional[str]
+ prioritize_unhealthy_instances: Optional[bool]
+ rollback_failed_instances_on_policy_breach: Optional[bool]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ enable_cross_zone_upgrade: Optional[bool] = ...,
+ max_batch_instance_percent: Optional[int] = ...,
+ max_unhealthy_instance_percent: Optional[int] = ...,
+ max_unhealthy_upgraded_instance_percent: Optional[int] = ...,
+ pause_time_between_batches: Optional[str] = ...,
+ prioritize_unhealthy_instances: Optional[bool] = ...,
+ rollback_failed_instances_on_policy_breach: Optional[bool] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ScaleSettings(_Model):
+ auto_scale: Optional[AutoScaleSettings]
+ fixed_scale: Optional[FixedScaleSettings]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ auto_scale: Optional[AutoScaleSettings] = ...,
+ fixed_scale: Optional[FixedScaleSettings] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.SecurityEncryptionTypes(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ DISK_WITH_VM_GUEST_STATE = "DiskWithVMGuestState"
+ NON_PERSISTED_TPM = "NonPersistedTPM"
+ VM_GUEST_STATE_ONLY = "VMGuestStateOnly"
+
+
+ class azure.mgmt.batch.models.SecurityProfile(_Model):
+ encryption_at_host: Optional[bool]
+ proxy_agent_settings: Optional[ProxyAgentSettings]
+ security_type: Optional[Union[str, SecurityTypes]]
+ uefi_settings: Optional[UefiSettings]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ encryption_at_host: Optional[bool] = ...,
+ proxy_agent_settings: Optional[ProxyAgentSettings] = ...,
+ security_type: Optional[Union[str, SecurityTypes]] = ...,
+ uefi_settings: Optional[UefiSettings] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.SecurityTypes(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ CONFIDENTIAL_VM = "confidentialVM"
+ TRUSTED_LAUNCH = "trustedLaunch"
+
+
+ class azure.mgmt.batch.models.ServiceArtifactReference(_Model):
+ id: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ id: str
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.Severity(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ ERROR = "Error"
+ WARNING = "Warning"
+
+
+ class azure.mgmt.batch.models.SkuCapability(_Model):
+ name: Optional[str]
+ value: Optional[str]
+
+
+ class azure.mgmt.batch.models.StartTask(_Model):
+ command_line: Optional[str]
+ container_settings: Optional[TaskContainerSettings]
+ environment_settings: Optional[list[EnvironmentSetting]]
+ max_task_retry_count: Optional[int]
+ resource_files: Optional[list[ResourceFile]]
+ user_identity: Optional[UserIdentity]
+ wait_for_success: Optional[bool]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ command_line: Optional[str] = ...,
+ container_settings: Optional[TaskContainerSettings] = ...,
+ environment_settings: Optional[list[EnvironmentSetting]] = ...,
+ max_task_retry_count: Optional[int] = ...,
+ resource_files: Optional[list[ResourceFile]] = ...,
+ user_identity: Optional[UserIdentity] = ...,
+ wait_for_success: Optional[bool] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.StorageAccountType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ PREMIUM_LRS = "Premium_LRS"
+ STANDARD_LRS = "Standard_LRS"
+ STANDARD_SSD_LRS = "StandardSSD_LRS"
+
+
+ class azure.mgmt.batch.models.SupportedSku(_Model):
+ batch_support_end_of_life: Optional[datetime]
+ capabilities: Optional[list[SkuCapability]]
+ family_name: Optional[str]
+ name: Optional[str]
+
+
+ class azure.mgmt.batch.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.batch.models.TaskContainerSettings(_Model):
+ container_host_batch_bind_mounts: Optional[list[ContainerHostBatchBindMountEntry]]
+ container_run_options: Optional[str]
+ image_name: str
+ registry: Optional[ContainerRegistry]
+ working_directory: Optional[Union[str, ContainerWorkingDirectory]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ container_host_batch_bind_mounts: Optional[list[ContainerHostBatchBindMountEntry]] = ...,
+ container_run_options: Optional[str] = ...,
+ image_name: str,
+ registry: Optional[ContainerRegistry] = ...,
+ working_directory: Optional[Union[str, ContainerWorkingDirectory]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.TaskSchedulingPolicy(_Model):
+ job_default_order: Optional[Union[str, JobDefaultOrder]]
+ node_fill_type: Union[str, ComputeNodeFillType]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ job_default_order: Optional[Union[str, JobDefaultOrder]] = ...,
+ node_fill_type: Union[str, ComputeNodeFillType]
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.TrackedResource(Resource):
+ id: str
+ location: str
+ name: str
+ system_data: SystemData
+ tags: Optional[dict[str, str]]
+ type: str
+
+ @overload
+ def __init__(
+ self,
+ *,
+ location: str,
+ tags: Optional[dict[str, str]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.UefiSettings(_Model):
+ secure_boot_enabled: Optional[bool]
+ v_tpm_enabled: Optional[bool]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ secure_boot_enabled: Optional[bool] = ...,
+ v_tpm_enabled: Optional[bool] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.UpgradeMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ AUTOMATIC = "automatic"
+ MANUAL = "manual"
+ ROLLING = "rolling"
+
+
+ class azure.mgmt.batch.models.UpgradePolicy(_Model):
+ automatic_os_upgrade_policy: Optional[AutomaticOSUpgradePolicy]
+ mode: Union[str, UpgradeMode]
+ rolling_upgrade_policy: Optional[RollingUpgradePolicy]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ automatic_os_upgrade_policy: Optional[AutomaticOSUpgradePolicy] = ...,
+ mode: Union[str, UpgradeMode],
+ rolling_upgrade_policy: Optional[RollingUpgradePolicy] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.UserAccount(_Model):
+ elevation_level: Optional[Union[str, ElevationLevel]]
+ linux_user_configuration: Optional[LinuxUserConfiguration]
+ name: str
+ password: str
+ windows_user_configuration: Optional[WindowsUserConfiguration]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ elevation_level: Optional[Union[str, ElevationLevel]] = ...,
+ linux_user_configuration: Optional[LinuxUserConfiguration] = ...,
+ name: str,
+ password: str,
+ windows_user_configuration: Optional[WindowsUserConfiguration] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.UserAssignedIdentities(_Model):
+ client_id: Optional[str]
+ principal_id: Optional[str]
+
+
+ class azure.mgmt.batch.models.UserIdentity(_Model):
+ auto_user: Optional[AutoUserSpecification]
+ user_name: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ auto_user: Optional[AutoUserSpecification] = ...,
+ user_name: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.VMDiskSecurityProfile(_Model):
+ disk_encryption_set: Optional[DiskEncryptionSetParameters]
+ security_encryption_type: Optional[Union[str, SecurityEncryptionTypes]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ disk_encryption_set: Optional[DiskEncryptionSetParameters] = ...,
+ security_encryption_type: Optional[Union[str, SecurityEncryptionTypes]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.VMExtension(_Model):
+ auto_upgrade_minor_version: Optional[bool]
+ enable_automatic_upgrade: Optional[bool]
+ name: str
+ protected_settings: Optional[Any]
+ provision_after_extensions: Optional[list[str]]
+ publisher: str
+ settings: Optional[Any]
+ type: str
+ type_handler_version: Optional[str]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ auto_upgrade_minor_version: Optional[bool] = ...,
+ enable_automatic_upgrade: Optional[bool] = ...,
+ name: str,
+ protected_settings: Optional[Any] = ...,
+ provision_after_extensions: Optional[list[str]] = ...,
+ publisher: str,
+ settings: Optional[Any] = ...,
+ type: str,
+ type_handler_version: Optional[str] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.VirtualMachineConfiguration(_Model):
+ container_configuration: Optional[ContainerConfiguration]
+ data_disks: Optional[list[DataDisk]]
+ disk_encryption_configuration: Optional[DiskEncryptionConfiguration]
+ extensions: Optional[list[VMExtension]]
+ hardware_profile: Optional[HardwareProfile]
+ image_reference: ImageReference
+ license_type: Optional[str]
+ node_agent_sku_id: str
+ node_placement_configuration: Optional[NodePlacementConfiguration]
+ os_disk: Optional[OSDisk]
+ placement: Optional[Placement]
+ resiliency_policy: Optional[ResiliencyPolicy]
+ security_profile: Optional[SecurityProfile]
+ service_artifact_reference: Optional[ServiceArtifactReference]
+ windows_configuration: Optional[WindowsConfiguration]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ container_configuration: Optional[ContainerConfiguration] = ...,
+ data_disks: Optional[list[DataDisk]] = ...,
+ disk_encryption_configuration: Optional[DiskEncryptionConfiguration] = ...,
+ extensions: Optional[list[VMExtension]] = ...,
+ hardware_profile: Optional[HardwareProfile] = ...,
+ image_reference: ImageReference,
+ license_type: Optional[str] = ...,
+ node_agent_sku_id: str,
+ node_placement_configuration: Optional[NodePlacementConfiguration] = ...,
+ os_disk: Optional[OSDisk] = ...,
+ placement: Optional[Placement] = ...,
+ resiliency_policy: Optional[ResiliencyPolicy] = ...,
+ security_profile: Optional[SecurityProfile] = ...,
+ service_artifact_reference: Optional[ServiceArtifactReference] = ...,
+ windows_configuration: Optional[WindowsConfiguration] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.VirtualMachineConfigurationPatch(_Model):
+ container_configuration: Optional[ContainerConfiguration]
+ data_disks: Optional[list[DataDisk]]
+ disk_encryption_configuration: Optional[DiskEncryptionConfiguration]
+ extensions: Optional[list[VMExtension]]
+ hardware_profile: Optional[HardwareProfile]
+ image_reference: ImageReference
+ license_type: Optional[str]
+ node_agent_sku_id: str
+ node_placement_configuration: Optional[NodePlacementConfiguration]
+ os_disk: Optional[OSDisk]
+ placement: Optional[PlacementPatch]
+ resiliency_policy: Optional[ResiliencyPolicyPatch]
+ security_profile: Optional[SecurityProfile]
+ service_artifact_reference: Optional[ServiceArtifactReference]
+ windows_configuration: Optional[WindowsConfiguration]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ container_configuration: Optional[ContainerConfiguration] = ...,
+ data_disks: Optional[list[DataDisk]] = ...,
+ disk_encryption_configuration: Optional[DiskEncryptionConfiguration] = ...,
+ extensions: Optional[list[VMExtension]] = ...,
+ hardware_profile: Optional[HardwareProfile] = ...,
+ image_reference: ImageReference,
+ license_type: Optional[str] = ...,
+ node_agent_sku_id: str,
+ node_placement_configuration: Optional[NodePlacementConfiguration] = ...,
+ os_disk: Optional[OSDisk] = ...,
+ placement: Optional[PlacementPatch] = ...,
+ resiliency_policy: Optional[ResiliencyPolicyPatch] = ...,
+ security_profile: Optional[SecurityProfile] = ...,
+ service_artifact_reference: Optional[ServiceArtifactReference] = ...,
+ windows_configuration: Optional[WindowsConfiguration] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.VirtualMachineFamilyCoreQuota(_Model):
+ core_quota: Optional[int]
+ name: Optional[str]
+
+
+ class azure.mgmt.batch.models.VirtualMachineSkuAllocationStrategy(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ CAPACITY_OPTIMIZED = "CapacityOptimized"
+ LOWEST_PRICE = "LowestPrice"
+ PRIORITIZED = "Prioritized"
+
+
+ class azure.mgmt.batch.models.VirtualMachineSkuProfile(_Model):
+ allocation_strategy: Optional[Union[str, VirtualMachineSkuAllocationStrategy]]
+ vm_sizes: Optional[list[VirtualMachineSkuProfileVmSize]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ allocation_strategy: Optional[Union[str, VirtualMachineSkuAllocationStrategy]] = ...,
+ vm_sizes: Optional[list[VirtualMachineSkuProfileVmSize]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.VirtualMachineSkuProfileVmSize(_Model):
+ name: str
+ rank: Optional[int]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ name: str,
+ rank: Optional[int] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.VmSizeProperties(_Model):
+ v_cpus_available: Optional[int]
+ v_cpus_per_core: Optional[int]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ v_cpus_available: Optional[int] = ...,
+ v_cpus_per_core: Optional[int] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.WindowsConfiguration(_Model):
+ enable_automatic_updates: Optional[bool]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ enable_automatic_updates: Optional[bool] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.WindowsUserConfiguration(_Model):
+ login_mode: Optional[Union[str, LoginMode]]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ login_mode: Optional[Union[str, LoginMode]] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ZoneAllocationPolicy(_Model):
+ max_instance_percent_per_zone_policy: Optional[MaxInstancePercentPerZonePolicy]
+ max_zone_count: Optional[int]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ max_instance_percent_per_zone_policy: Optional[MaxInstancePercentPerZonePolicy] = ...,
+ max_zone_count: Optional[int] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ZoneAllocationPolicyPatch(_Model):
+ max_instance_percent_per_zone_policy: Optional[MaxInstancePercentPerZonePolicyPatch]
+ max_zone_count: Optional[int]
+
+ @overload
+ def __init__(
+ self,
+ *,
+ max_instance_percent_per_zone_policy: Optional[MaxInstancePercentPerZonePolicyPatch] = ...,
+ max_zone_count: Optional[int] = ...
+ ) -> None: ...
+
+ @overload
+ def __init__(self, mapping: Mapping[str, Any]) -> None: ...
+
+
+ class azure.mgmt.batch.models.ZonePlacementPolicyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ AUTO = "Auto"
+
+
+namespace azure.mgmt.batch.operations
+
+ class azure.mgmt.batch.operations.ApplicationOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @overload
+ def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ parameters: Optional[Application] = None,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> Application: ...
+
+ @overload
+ def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ parameters: Optional[Application] = None,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> Application: ...
+
+ @overload
+ def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ parameters: Optional[IO[bytes]] = None,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> Application: ...
+
+ @distributed_trace
+ def delete(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ **kwargs: Any
+ ) -> None: ...
+
+ @distributed_trace
+ def get(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ **kwargs: Any
+ ) -> Application: ...
+
+ @distributed_trace
+ def list(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ *,
+ maxresults: Optional[int] = ...,
+ **kwargs: Any
+ ) -> ItemPaged[Application]: ...
+
+ @overload
+ def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ parameters: Application,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> Application: ...
+
+ @overload
+ def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ parameters: Application,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> Application: ...
+
+ @overload
+ def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> Application: ...
+
+
+ class azure.mgmt.batch.operations.ApplicationPackageOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @overload
+ def activate(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ parameters: ActivateApplicationPackageParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> ApplicationPackage: ...
+
+ @overload
+ def activate(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ parameters: ActivateApplicationPackageParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> ApplicationPackage: ...
+
+ @overload
+ def activate(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> ApplicationPackage: ...
+
+ @overload
+ def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ parameters: Optional[ApplicationPackage] = None,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> ApplicationPackage: ...
+
+ @overload
+ def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ parameters: Optional[ApplicationPackage] = None,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> ApplicationPackage: ...
+
+ @overload
+ def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ parameters: Optional[IO[bytes]] = None,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> ApplicationPackage: ...
+
+ @distributed_trace
+ def delete(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ **kwargs: Any
+ ) -> None: ...
+
+ @distributed_trace
+ def get(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ version_name: str,
+ **kwargs: Any
+ ) -> ApplicationPackage: ...
+
+ @distributed_trace
+ def list(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ application_name: str,
+ *,
+ maxresults: Optional[int] = ...,
+ **kwargs: Any
+ ) -> ItemPaged[ApplicationPackage]: ...
+
+
+ class azure.mgmt.batch.operations.BatchAccountOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @overload
+ def begin_create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: BatchAccountCreateParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> LROPoller[BatchAccount]: ...
+
+ @overload
+ def begin_create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: BatchAccountCreateParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> LROPoller[BatchAccount]: ...
+
+ @overload
+ def begin_create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> LROPoller[BatchAccount]: ...
+
+ @distributed_trace
+ def begin_delete(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ **kwargs: Any
+ ) -> LROPoller[None]: ...
+
+ @distributed_trace
+ def get(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ **kwargs: Any
+ ) -> BatchAccount: ...
+
+ @distributed_trace
+ def get_detector(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ detector_id: str,
+ **kwargs: Any
+ ) -> DetectorResponse: ...
+
+ @distributed_trace
+ def get_keys(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ **kwargs: Any
+ ) -> BatchAccountKeys: ...
+
+ @distributed_trace
+ def list(self, **kwargs: Any) -> ItemPaged[BatchAccount]: ...
+
+ @distributed_trace
+ def list_by_resource_group(
+ self,
+ resource_group_name: str,
+ **kwargs: Any
+ ) -> ItemPaged[BatchAccount]: ...
+
+ @distributed_trace
+ def list_detectors(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ **kwargs: Any
+ ) -> ItemPaged[DetectorResponse]: ...
+
+ @distributed_trace
+ def list_outbound_network_dependencies_endpoints(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ **kwargs: Any
+ ) -> ItemPaged[OutboundEnvironmentEndpoint]: ...
+
+ @overload
+ def regenerate_key(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: BatchAccountRegenerateKeyParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> BatchAccountKeys: ...
+
+ @overload
+ def regenerate_key(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: BatchAccountRegenerateKeyParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> BatchAccountKeys: ...
+
+ @overload
+ def regenerate_key(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> BatchAccountKeys: ...
+
+ @distributed_trace
+ def synchronize_auto_storage_keys(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ **kwargs: Any
+ ) -> None: ...
+
+ @overload
+ def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: BatchAccountUpdateParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> BatchAccount: ...
+
+ @overload
+ def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: BatchAccountUpdateParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> BatchAccount: ...
+
+ @overload
+ def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> BatchAccount: ...
+
+
+ class azure.mgmt.batch.operations.LocationOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @overload
+ def check_name_availability(
+ self,
+ location_name: str,
+ parameters: CheckNameAvailabilityParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> CheckNameAvailabilityResult: ...
+
+ @overload
+ def check_name_availability(
+ self,
+ location_name: str,
+ parameters: CheckNameAvailabilityParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> CheckNameAvailabilityResult: ...
+
+ @overload
+ def check_name_availability(
+ self,
+ location_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
+ ) -> CheckNameAvailabilityResult: ...
+
+ @distributed_trace
+ def get_quotas(
+ self,
+ location_name: str,
+ **kwargs: Any
+ ) -> BatchLocationQuota: ...
+
+ @distributed_trace
+ def list_supported_virtual_machine_skus(
+ self,
+ location_name: str,
+ *,
+ filter: Optional[str] = ...,
+ maxresults: Optional[int] = ...,
+ **kwargs: Any
+ ) -> ItemPaged[SupportedSku]: ...
+
+
+ class azure.mgmt.batch.operations.NetworkSecurityPerimeterOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @distributed_trace
+ def begin_reconcile_configuration(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ network_security_perimeter_configuration_name: str,
+ **kwargs: Any
+ ) -> LROPoller[None]: ...
+
+ @distributed_trace
+ def get_configuration(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ network_security_perimeter_configuration_name: str,
+ **kwargs: Any
+ ) -> NetworkSecurityPerimeterConfiguration: ...
+
+ @distributed_trace
+ def list_configurations(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ **kwargs: Any
+ ) -> ItemPaged[NetworkSecurityPerimeterConfiguration]: ...
+
+
+ class azure.mgmt.batch.operations.Operations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @distributed_trace
+ def list(self, **kwargs: Any) -> ItemPaged[Operation]: ...
+
+
+ class azure.mgmt.batch.operations.PoolOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @distributed_trace
+ def begin_delete(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ **kwargs: Any
+ ) -> LROPoller[None]: ...
+
+ @overload
+ def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ parameters: Pool,
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @overload
+ def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ parameters: Pool,
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @overload
+ def create(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @distributed_trace
+ def disable_auto_scale(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @distributed_trace
+ def get(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @distributed_trace
+ def list_by_batch_account(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ *,
+ filter: Optional[str] = ...,
+ maxresults: Optional[int] = ...,
+ select: Optional[str] = ...,
+ **kwargs: Any
+ ) -> ItemPaged[Pool]: ...
+
+ @distributed_trace
+ def stop_resize(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @overload
+ def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ parameters: PoolPatch,
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @overload
+ def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ parameters: PoolPatch,
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> Pool: ...
+
+ @overload
+ def update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ pool_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> Pool: ...
+
+
+ class azure.mgmt.batch.operations.PrivateEndpointConnectionOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @distributed_trace
+ def begin_delete(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ private_endpoint_connection_name: str,
+ **kwargs: Any
+ ) -> LROPoller[None]: ...
+
+ @overload
+ def begin_update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ private_endpoint_connection_name: str,
+ parameters: PrivateEndpointConnection,
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> LROPoller[PrivateEndpointConnection]: ...
+
+ @overload
+ def begin_update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ private_endpoint_connection_name: str,
+ parameters: PrivateEndpointConnection,
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> LROPoller[PrivateEndpointConnection]: ...
+
+ @overload
+ def begin_update(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ private_endpoint_connection_name: str,
+ parameters: IO[bytes],
+ *,
+ content_type: str = "application/json",
+ etag: Optional[str] = ...,
+ match_condition: Optional[MatchConditions] = ...,
+ **kwargs: Any
+ ) -> LROPoller[PrivateEndpointConnection]: ...
+
+ @distributed_trace
+ def get(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ private_endpoint_connection_name: str,
+ **kwargs: Any
+ ) -> PrivateEndpointConnection: ...
+
+ @distributed_trace
+ def list_by_batch_account(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ *,
+ maxresults: Optional[int] = ...,
+ **kwargs: Any
+ ) -> ItemPaged[PrivateEndpointConnection]: ...
+
+
+ class azure.mgmt.batch.operations.PrivateLinkResourceOperations:
+
+ def __init__(
+ self,
+ *args,
+ **kwargs
+ ) -> None: ...
+
+ @distributed_trace
+ def get(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ private_link_resource_name: str,
+ **kwargs: Any
+ ) -> PrivateLinkResource: ...
+
+ @distributed_trace
+ def list_by_batch_account(
+ self,
+ resource_group_name: str,
+ account_name: str,
+ *,
+ maxresults: Optional[int] = ...,
+ **kwargs: Any
+ ) -> ItemPaged[PrivateLinkResource]: ...
+
+
+namespace azure.mgmt.batch.types
+
+ class azure.mgmt.batch.types.ActivateApplicationPackageParameters(TypedDict, total=False):
+ key "format": Required[str]
+ format: str
+
+
+ class azure.mgmt.batch.types.Application(ProxyResource):
+ key "etag": str
+ key "id": str
+ key "name": str
+ key "properties": ForwardRef('ApplicationProperties', module='types')
+ key "systemData": ForwardRef('SystemData', module='types')
+ key "type": str
+ etag: str
+ id: str
+ name: str
+ properties: ApplicationProperties
+ systemData: SystemData
+ tags: dict[str, str]
+ type: str
+
+
+ class azure.mgmt.batch.types.ApplicationPackage(ProxyResource):
+ key "etag": str
+ key "id": str
+ key "name": str
+ key "properties": ForwardRef('ApplicationPackageProperties', module='types')
+ key "systemData": ForwardRef('SystemData', module='types')
+ key "type": str
+ etag: str
+ id: str
+ name: str
+ properties: ApplicationPackageProperties
+ systemData: SystemData
+ tags: dict[str, str]
+ type: str
+
+
+ class azure.mgmt.batch.types.ApplicationPackageProperties(TypedDict, total=False):
+ key "format": str
+ key "lastActivationTime": str
+ key "state": Union[str, PackageState]
+ key "storageUrl": str
+ key "storageUrlExpiry": str
+ format: str
+ lastActivationTime: str
+ state: Union[str, PackageState]
+ storageUrl: str
+ storageUrlExpiry: str
+
+
+ class azure.mgmt.batch.types.ApplicationPackageReference(TypedDict, total=False):
+ key "id": Required[str]
+ key "version": str
+ id: str
+ version: str
+
+
+ class azure.mgmt.batch.types.ApplicationProperties(TypedDict, total=False):
+ key "allowUpdates": bool
+ key "defaultVersion": str
+ key "displayName": str
+ allowUpdates: bool
+ defaultVersion: str
+ displayName: str
+
+
+ class azure.mgmt.batch.types.AutoScaleRun(TypedDict, total=False):
+ key "error": ForwardRef('AutoScaleRunError', module='types')
+ key "evaluationTime": Required[str]
+ key "results": str
+ error: AutoScaleRunError
+ evaluationTime: str
+ results: str
+
+
+ class azure.mgmt.batch.types.AutoScaleRunError(TypedDict, total=False):
+ key "code": Required[str]
+ key "message": Required[str]
+ code: str
+ details: list[AutoScaleRunError]
+ message: str
+
+
+ class azure.mgmt.batch.types.AutoScaleSettings(TypedDict, total=False):
+ key "evaluationInterval": str
+ key "formula": Required[str]
+ evaluationInterval: str
+ formula: str
+
+
+ class azure.mgmt.batch.types.AutoStorageBaseProperties(TypedDict, total=False):
+ key "authenticationMode": Union[str, AutoStorageAuthenticationMode]
+ key "nodeIdentityReference": ForwardRef('ComputeNodeIdentityReference', module='types')
+ key "storageAccountId": Required[str]
+ authenticationMode: Union[str, AutoStorageAuthenticationMode]
+ nodeIdentityReference: ComputeNodeIdentityReference
+ storageAccountId: str
+
+
+ class azure.mgmt.batch.types.AutoUserSpecification(TypedDict, total=False):
+ key "elevationLevel": Union[str, ElevationLevel]
+ key "scope": Union[str, AutoUserScope]
+ elevationLevel: Union[str, ElevationLevel]
+ scope: Union[str, AutoUserScope]
+
+
+ class azure.mgmt.batch.types.AutomaticOSUpgradePolicy(TypedDict, total=False):
+ key "disableAutomaticRollback": bool
+ key "enableAutomaticOSUpgrade": bool
+ key "osRollingUpgradeDeferral": bool
+ key "useRollingUpgradePolicy": bool
+ disableAutomaticRollback: bool
+ enableAutomaticOSUpgrade: bool
+ osRollingUpgradeDeferral: bool
+ useRollingUpgradePolicy: bool
+
+
+ class azure.mgmt.batch.types.AzureBlobFileSystemConfiguration(TypedDict, total=False):
+ key "accountKey": str
+ key "accountName": Required[str]
+ key "blobfuseOptions": str
+ key "containerName": Required[str]
+ key "identityReference": ForwardRef('ComputeNodeIdentityReference', module='types')
+ key "relativeMountPath": Required[str]
+ key "sasKey": str
+ accountKey: str
+ accountName: str
+ blobfuseOptions: str
+ containerName: str
+ identityReference: ComputeNodeIdentityReference
+ relativeMountPath: str
+ sasKey: str
+
+
+ class azure.mgmt.batch.types.AzureFileShareConfiguration(TypedDict, total=False):
+ key "accountKey": Required[str]
+ key "accountName": Required[str]
+ key "azureFileUrl": Required[str]
+ key "mountOptions": str
+ key "relativeMountPath": Required[str]
+ accountKey: str
+ accountName: str
+ azureFileUrl: str
+ mountOptions: str
+ relativeMountPath: str
+
+
+ class azure.mgmt.batch.types.BatchAccountCreateParameters(TypedDict, total=False):
+ key "identity": ForwardRef('BatchAccountIdentity', module='types')
+ key "location": Required[str]
+ key "properties": ForwardRef('BatchAccountCreateProperties', module='types')
+ identity: BatchAccountIdentity
+ location: str
+ properties: BatchAccountCreateProperties
+ tags: dict[str, str]
+
+
+ class azure.mgmt.batch.types.BatchAccountCreateProperties(TypedDict, total=False):
+ key "allowedAuthenticationModes": Optional[list[Union[str, AuthenticationMode]]]
+ key "autoStorage": ForwardRef('AutoStorageBaseProperties', module='types')
+ key "encryption": ForwardRef('EncryptionProperties', module='types')
+ key "keyVaultReference": ForwardRef('KeyVaultReference', module='types')
+ key "networkProfile": ForwardRef('NetworkProfile', module='types')
+ key "poolAllocationMode": Union[str, PoolAllocationMode]
+ key "publicNetworkAccess": Union[str, PublicNetworkAccessType]
+ allowedAuthenticationModes: list[Union[str, AuthenticationMode]]
+ autoStorage: AutoStorageBaseProperties
+ encryption: EncryptionProperties
+ keyVaultReference: KeyVaultReference
+ networkProfile: NetworkProfile
+ poolAllocationMode: Union[str, PoolAllocationMode]
+ publicNetworkAccess: Union[str, PublicNetworkAccessType]
+
+
+ class azure.mgmt.batch.types.BatchAccountIdentity(TypedDict, total=False):
+ key "principalId": str
+ key "tenantId": str
+ key "type": Required[Union[str, ResourceIdentityType]]
+ principalId: str
+ tenantId: str
+ type: Union[str, ResourceIdentityType]
+ userAssignedIdentities: dict[str, UserAssignedIdentities]
+
+
+ class azure.mgmt.batch.types.BatchAccountRegenerateKeyParameters(TypedDict, total=False):
+ key "keyName": Required[Union[str, AccountKeyType]]
+ keyName: Union[str, AccountKeyType]
+
+
+ class azure.mgmt.batch.types.BatchAccountUpdateParameters(TypedDict, total=False):
+ key "identity": ForwardRef('BatchAccountIdentity', module='types')
+ key "properties": ForwardRef('BatchAccountUpdateProperties', module='types')
+ identity: BatchAccountIdentity
+ properties: BatchAccountUpdateProperties
+ tags: dict[str, str]
+
+
+ class azure.mgmt.batch.types.BatchAccountUpdateProperties(TypedDict, total=False):
+ key "allowedAuthenticationModes": Optional[list[Union[str, AuthenticationMode]]]
+ key "autoStorage": ForwardRef('AutoStorageBaseProperties', module='types')
+ key "encryption": ForwardRef('EncryptionProperties', module='types')
+ key "networkProfile": ForwardRef('NetworkProfile', module='types')
+ key "publicNetworkAccess": Union[str, PublicNetworkAccessType]
+ allowedAuthenticationModes: list[Union[str, AuthenticationMode]]
+ autoStorage: AutoStorageBaseProperties
+ encryption: EncryptionProperties
+ networkProfile: NetworkProfile
+ publicNetworkAccess: Union[str, PublicNetworkAccessType]
+
+
+ class azure.mgmt.batch.types.BatchPoolIdentity(TypedDict, total=False):
+ key "type": Required[Union[str, PoolIdentityType]]
+ type: Union[str, PoolIdentityType]
+ userAssignedIdentities: dict[str, UserAssignedIdentities]
+
+
+ class azure.mgmt.batch.types.CIFSMountConfiguration(TypedDict, total=False):
+ key "mountOptions": str
+ key "password": Required[str]
+ key "relativeMountPath": Required[str]
+ key "source": Required[str]
+ key "userName": Required[str]
+ mountOptions: str
+ password: str
+ relativeMountPath: str
+ source: str
+ userName: str
+
+
+ class azure.mgmt.batch.types.CheckNameAvailabilityParameters(TypedDict, total=False):
+ key "name": Required[str]
+ key "type": Required[Union[str, ResourceType]]
+ name: str
+ type: Union[str, ResourceType]
+
+
+ class azure.mgmt.batch.types.ComputeNodeIdentityReference(TypedDict, total=False):
+ key "resourceId": str
+ resourceId: str
+
+
+ class azure.mgmt.batch.types.ContainerConfiguration(TypedDict, total=False):
+ key "type": Required[Union[str, ContainerType]]
+ containerImageNames: list[str]
+ containerRegistries: list[ContainerRegistry]
+ type: Union[str, ContainerType]
+
+
+ class azure.mgmt.batch.types.ContainerHostBatchBindMountEntry(TypedDict, total=False):
+ key "isReadOnly": bool
+ key "source": Union[str, ContainerHostDataPath]
+ isReadOnly: bool
+ source: Union[str, ContainerHostDataPath]
+
+
+ class azure.mgmt.batch.types.ContainerRegistry(TypedDict, total=False):
+ key "identityReference": ForwardRef('ComputeNodeIdentityReference', module='types')
+ key "password": str
+ key "registryServer": str
+ key "username": str
+ identityReference: ComputeNodeIdentityReference
+ password: str
+ registryServer: str
+ username: str
+
+
+ class azure.mgmt.batch.types.DataDisk(TypedDict, total=False):
+ key "caching": Union[str, CachingType]
+ key "diskSizeGB": Required[int]
+ key "lun": Required[int]
+ key "managedDisk": ForwardRef('ManagedDisk', module='types')
+ caching: Union[str, CachingType]
+ diskSizeGB: int
+ lun: int
+ managedDisk: ManagedDisk
+
+
+ class azure.mgmt.batch.types.DeploymentConfiguration(TypedDict, total=False):
+ key "virtualMachineConfiguration": ForwardRef('VirtualMachineConfiguration', module='types')
+ virtualMachineConfiguration: VirtualMachineConfiguration
+
+
+ class azure.mgmt.batch.types.DeploymentConfigurationPatch(TypedDict, total=False):
+ key "virtualMachineConfiguration": ForwardRef('VirtualMachineConfigurationPatch', module='types')
+ virtualMachineConfiguration: VirtualMachineConfigurationPatch
+
+
+ class azure.mgmt.batch.types.DiffDiskSettings(TypedDict, total=False):
+ key "placement": Union[str, DiffDiskPlacement]
+ placement: Union[str, DiffDiskPlacement]
+
+
+ class azure.mgmt.batch.types.DiskCustomerManagedKey(TypedDict, total=False):
+ key "identityReference": ForwardRef('ComputeNodeIdentityReference', module='types')
+ key "keyUrl": str
+ key "rotationToLatestKeyVersionEnabled": bool
+ identityReference: ComputeNodeIdentityReference
+ keyUrl: str
+ rotationToLatestKeyVersionEnabled: bool
+
+
+ class azure.mgmt.batch.types.DiskEncryptionConfiguration(TypedDict, total=False):
+ key "customerManagedKey": ForwardRef('DiskCustomerManagedKey', module='types')
+ customerManagedKey: DiskCustomerManagedKey
+ targets: list[Union[str, DiskEncryptionTarget]]
+
+
+ class azure.mgmt.batch.types.DiskEncryptionSetParameters(TypedDict, total=False):
+ key "id": Required[str]
+ id: str
+
+
+ class azure.mgmt.batch.types.EncryptionProperties(TypedDict, total=False):
+ key "keySource": Union[str, KeySource]
+ key "keyVaultProperties": ForwardRef('KeyVaultProperties', module='types')
+ keySource: Union[str, KeySource]
+ keyVaultProperties: KeyVaultProperties
+
+
+ class azure.mgmt.batch.types.EndpointAccessProfile(TypedDict, total=False):
+ key "defaultAction": Required[Union[str, EndpointAccessDefaultAction]]
+ defaultAction: Union[str, EndpointAccessDefaultAction]
+ ipRules: list[IPRule]
+
+
+ class azure.mgmt.batch.types.EnvironmentSetting(TypedDict, total=False):
+ key "name": Required[str]
+ key "value": str
+ name: str
+ value: str
+
+
+ class azure.mgmt.batch.types.FixedScaleSettings(TypedDict, total=False):
+ key "nodeDeallocationOption": Union[str, RequestedComputeNodeDeallocationOption]
+ key "resizeTimeout": str
+ key "targetDedicatedNodes": int
+ key "targetLowPriorityNodes": int
+ nodeDeallocationOption: Union[str, RequestedComputeNodeDeallocationOption]
+ resizeTimeout: str
+ targetDedicatedNodes: int
+ targetLowPriorityNodes: int
+
+
+ class azure.mgmt.batch.types.HardwareProfile(TypedDict, total=False):
+ key "vmSizeProperties": ForwardRef('VmSizeProperties', module='types')
+ vmSizeProperties: VmSizeProperties
+
+
+ class azure.mgmt.batch.types.HostEndpointSettings(TypedDict, total=False):
+ key "inVMAccessControlProfileReferenceId": str
+ key "mode": Union[str, HostEndpointSettingsModeTypes]
+ inVMAccessControlProfileReferenceId: str
+ mode: Union[str, HostEndpointSettingsModeTypes]
+
+
+ class azure.mgmt.batch.types.IPRule(TypedDict, total=False):
+ key "action": Required[Union[str, IPRuleAction]]
+ key "value": Required[str]
+ action: Union[str, IPRuleAction]
+ value: str
+
+
+ class azure.mgmt.batch.types.IPTag(TypedDict, total=False):
+ key "ipTagType": str
+ key "tag": str
+ ipTagType: str
+ tag: str
+
+
+ class azure.mgmt.batch.types.ImageReference(TypedDict, total=False):
+ key "communityGalleryImageId": str
+ key "id": str
+ key "offer": str
+ key "publisher": str
+ key "sharedGalleryImageId": str
+ key "sku": str
+ key "version": str
+ communityGalleryImageId: str
+ id: str
+ offer: str
+ publisher: str
+ sharedGalleryImageId: str
+ sku: str
+ version: str
+
+
+ class azure.mgmt.batch.types.InboundNatPool(TypedDict, total=False):
+ key "backendPort": Required[int]
+ key "frontendPortRangeEnd": Required[int]
+ key "frontendPortRangeStart": Required[int]
+ key "name": Required[str]
+ key "protocol": Required[Union[str, InboundEndpointProtocol]]
+ backendPort: int
+ frontendPortRangeEnd: int
+ frontendPortRangeStart: int
+ name: str
+ networkSecurityGroupRules: list[NetworkSecurityGroupRule]
+ protocol: Union[str, InboundEndpointProtocol]
+
+
+ class azure.mgmt.batch.types.KeyVaultProperties(TypedDict, total=False):
+ key "keyIdentifier": str
+ keyIdentifier: str
+
+
+ class azure.mgmt.batch.types.KeyVaultReference(TypedDict, total=False):
+ key "id": Required[str]
+ key "url": Required[str]
+ id: str
+ url: str
+
+
+ class azure.mgmt.batch.types.LinuxUserConfiguration(TypedDict, total=False):
+ key "gid": int
+ key "sshPrivateKey": str
+ key "uid": int
+ gid: int
+ sshPrivateKey: str
+ uid: int
+
+
+ class azure.mgmt.batch.types.ManagedDisk(TypedDict, total=False):
+ key "diskEncryptionSet": ForwardRef('DiskEncryptionSetParameters', module='types')
+ key "securityProfile": ForwardRef('VMDiskSecurityProfile', module='types')
+ key "storageAccountType": Union[str, StorageAccountType]
+ diskEncryptionSet: DiskEncryptionSetParameters
+ securityProfile: VMDiskSecurityProfile
+ storageAccountType: Union[str, StorageAccountType]
+
+
+ class azure.mgmt.batch.types.MaxInstancePercentPerZonePolicy(TypedDict, total=False):
+ key "enabled": bool
+ key "value": Required[int]
+ enabled: bool
+ value: int
+
+
+ class azure.mgmt.batch.types.MaxInstancePercentPerZonePolicyPatch(TypedDict, total=False):
+ key "enabled": bool
+ key "value": int
+ enabled: bool
+ value: int
+
+
+ class azure.mgmt.batch.types.MetadataItem(TypedDict, total=False):
+ key "name": Required[str]
+ key "value": Required[str]
+ name: str
+ value: str
+
+
+ class azure.mgmt.batch.types.MountConfiguration(TypedDict, total=False):
+ key "azureBlobFileSystemConfiguration": ForwardRef('AzureBlobFileSystemConfiguration', module='types')
+ key "azureFileShareConfiguration": ForwardRef('AzureFileShareConfiguration', module='types')
+ key "cifsMountConfiguration": ForwardRef('CIFSMountConfiguration', module='types')
+ key "nfsMountConfiguration": ForwardRef('NFSMountConfiguration', module='types')
+ azureBlobFileSystemConfiguration: AzureBlobFileSystemConfiguration
+ azureFileShareConfiguration: AzureFileShareConfiguration
+ cifsMountConfiguration: CIFSMountConfiguration
+ nfsMountConfiguration: NFSMountConfiguration
+
+
+ class azure.mgmt.batch.types.NFSMountConfiguration(TypedDict, total=False):
+ key "mountOptions": str
+ key "relativeMountPath": Required[str]
+ key "source": Required[str]
+ mountOptions: str
+ relativeMountPath: str
+ source: str
+
+
+ class azure.mgmt.batch.types.NetworkConfiguration(TypedDict, total=False):
+ key "dynamicVnetAssignmentScope": Union[str, DynamicVNetAssignmentScope]
+ key "enableAcceleratedNetworking": bool
+ key "endpointConfiguration": ForwardRef('PoolEndpointConfiguration', module='types')
+ key "publicIPAddressConfiguration": ForwardRef('PublicIPAddressConfiguration', module='types')
+ key "subnetId": str
+ dynamicVnetAssignmentScope: Union[str, DynamicVNetAssignmentScope]
+ enableAcceleratedNetworking: bool
+ endpointConfiguration: PoolEndpointConfiguration
+ publicIPAddressConfiguration: PublicIPAddressConfiguration
+ subnetId: str
+
+
+ class azure.mgmt.batch.types.NetworkProfile(TypedDict, total=False):
+ key "accountAccess": ForwardRef('EndpointAccessProfile', module='types')
+ key "nodeManagementAccess": ForwardRef('EndpointAccessProfile', module='types')
+ accountAccess: EndpointAccessProfile
+ nodeManagementAccess: EndpointAccessProfile
+
+
+ class azure.mgmt.batch.types.NetworkSecurityGroupRule(TypedDict, total=False):
+ key "access": Required[Union[str, NetworkSecurityGroupRuleAccess]]
+ key "priority": Required[int]
+ key "sourceAddressPrefix": Required[str]
+ access: Union[str, NetworkSecurityGroupRuleAccess]
+ priority: int
+ sourceAddressPrefix: str
+ sourcePortRanges: list[str]
+
+
+ class azure.mgmt.batch.types.NodePlacementConfiguration(TypedDict, total=False):
+ key "policy": Union[str, NodePlacementPolicyType]
+ policy: Union[str, NodePlacementPolicyType]
+
+
+ class azure.mgmt.batch.types.OSDisk(TypedDict, total=False):
+ key "caching": Union[str, CachingType]
+ key "diskSizeGB": int
+ key "ephemeralOSDiskSettings": ForwardRef('DiffDiskSettings', module='types')
+ key "managedDisk": ForwardRef('ManagedDisk', module='types')
+ key "writeAcceleratorEnabled": bool
+ caching: Union[str, CachingType]
+ diskSizeGB: int
+ ephemeralOSDiskSettings: DiffDiskSettings
+ managedDisk: ManagedDisk
+ writeAcceleratorEnabled: bool
+
+
+ class azure.mgmt.batch.types.Placement(TypedDict, total=False):
+ key "zonePlacementPolicy": Required[Union[str, ZonePlacementPolicyType]]
+ zonePlacementPolicy: Union[str, ZonePlacementPolicyType]
+
+
+ class azure.mgmt.batch.types.PlacementPatch(TypedDict, total=False):
+ key "zonePlacementPolicy": Union[str, ZonePlacementPolicyType]
+ zonePlacementPolicy: Union[str, ZonePlacementPolicyType]
+
+
+ class azure.mgmt.batch.types.Pool(ProxyResource):
+ key "etag": str
+ key "id": str
+ key "identity": ForwardRef('BatchPoolIdentity', module='types')
+ key "name": str
+ key "properties": ForwardRef('PoolProperties', module='types')
+ key "systemData": ForwardRef('SystemData', module='types')
+ key "type": str
+ etag: str
+ id: str
+ identity: BatchPoolIdentity
+ name: str
+ properties: PoolProperties
+ systemData: SystemData
+ tags: dict[str, str]
+ type: str
+
+
+ class azure.mgmt.batch.types.PoolEndpointConfiguration(TypedDict, total=False):
+ key "inboundNatPools": Required[list[InboundNatPool]]
+ inboundNatPools: list[InboundNatPool]
+
+
+ class azure.mgmt.batch.types.PoolPatch(TypedDict, total=False):
+ key "etag": str
+ key "id": str
+ key "identity": ForwardRef('BatchPoolIdentity', module='types')
+ key "properties": ForwardRef('PoolPatchProperties', module='types')
+ key "systemData": ForwardRef('SystemData', module='types')
+ etag: str
+ id: str
+ identity: BatchPoolIdentity
+ properties: PoolPatchProperties
+ systemData: SystemData
+ tags: dict[str, str]
+
+
+ class azure.mgmt.batch.types.PoolPatchProperties(TypedDict, total=False):
+ key "allocationState": Union[str, AllocationState]
+ key "allocationStateTransitionTime": str
+ key "autoScaleRun": ForwardRef('AutoScaleRun', module='types')
+ key "creationTime": str
+ key "currentDedicatedNodes": int
+ key "currentLowPriorityNodes": int
+ key "deploymentConfiguration": ForwardRef('DeploymentConfigurationPatch', module='types')
+ key "displayName": str
+ key "interNodeCommunication": Union[str, InterNodeCommunicationState]
+ key "lastModified": str
+ key "networkConfiguration": ForwardRef('NetworkConfiguration', module='types')
+ key "provisioningState": Union[str, PoolProvisioningState]
+ key "provisioningStateTransitionTime": str
+ key "resizeOperationStatus": ForwardRef('ResizeOperationStatus', module='types')
+ key "scaleSettings": ForwardRef('ScaleSettings', module='types')
+ key "startTask": ForwardRef('StartTask', module='types')
+ key "taskSchedulingPolicy": ForwardRef('TaskSchedulingPolicy', module='types')
+ key "taskSlotsPerNode": int
+ key "upgradePolicy": ForwardRef('UpgradePolicy', module='types')
+ key "vmSize": str
+ key "vmSkuProfile": ForwardRef('VirtualMachineSkuProfile', module='types')
+ allocationState: Union[str, AllocationState]
+ allocationStateTransitionTime: str
+ applicationPackages: list[ApplicationPackageReference]
+ autoScaleRun: AutoScaleRun
+ creationTime: str
+ currentDedicatedNodes: int
+ currentLowPriorityNodes: int
+ deploymentConfiguration: DeploymentConfigurationPatch
+ displayName: str
+ interNodeCommunication: Union[str, InterNodeCommunicationState]
+ lastModified: str
+ metadata: list[MetadataItem]
+ mountConfiguration: list[MountConfiguration]
+ networkConfiguration: NetworkConfiguration
+ provisioningState: Union[str, PoolProvisioningState]
+ provisioningStateTransitionTime: str
+ resizeOperationStatus: ResizeOperationStatus
+ scaleSettings: ScaleSettings
+ startTask: StartTask
+ taskSchedulingPolicy: TaskSchedulingPolicy
+ taskSlotsPerNode: int
+ upgradePolicy: UpgradePolicy
+ userAccounts: list[UserAccount]
+ vmSize: str
+ vmSkuProfile: VirtualMachineSkuProfile
+
+
+ class azure.mgmt.batch.types.PoolProperties(TypedDict, total=False):
+ key "allocationState": Union[str, AllocationState]
+ key "allocationStateTransitionTime": str
+ key "autoScaleRun": ForwardRef('AutoScaleRun', module='types')
+ key "creationTime": str
+ key "currentDedicatedNodes": int
+ key "currentLowPriorityNodes": int
+ key "deploymentConfiguration": ForwardRef('DeploymentConfiguration', module='types')
+ key "displayName": str
+ key "interNodeCommunication": Union[str, InterNodeCommunicationState]
+ key "lastModified": str
+ key "networkConfiguration": ForwardRef('NetworkConfiguration', module='types')
+ key "provisioningState": Union[str, PoolProvisioningState]
+ key "provisioningStateTransitionTime": str
+ key "resizeOperationStatus": ForwardRef('ResizeOperationStatus', module='types')
+ key "scaleSettings": ForwardRef('ScaleSettings', module='types')
+ key "startTask": ForwardRef('StartTask', module='types')
+ key "taskSchedulingPolicy": ForwardRef('TaskSchedulingPolicy', module='types')
+ key "taskSlotsPerNode": int
+ key "upgradePolicy": ForwardRef('UpgradePolicy', module='types')
+ key "vmSize": str
+ key "vmSkuProfile": ForwardRef('VirtualMachineSkuProfile', module='types')
+ allocationState: Union[str, AllocationState]
+ allocationStateTransitionTime: str
+ applicationPackages: list[ApplicationPackageReference]
+ autoScaleRun: AutoScaleRun
+ creationTime: str
+ currentDedicatedNodes: int
+ currentLowPriorityNodes: int
+ deploymentConfiguration: DeploymentConfiguration
+ displayName: str
+ interNodeCommunication: Union[str, InterNodeCommunicationState]
+ lastModified: str
+ metadata: list[MetadataItem]
+ mountConfiguration: list[MountConfiguration]
+ networkConfiguration: NetworkConfiguration
+ provisioningState: Union[str, PoolProvisioningState]
+ provisioningStateTransitionTime: str
+ resizeOperationStatus: ResizeOperationStatus
+ scaleSettings: ScaleSettings
+ startTask: StartTask
+ taskSchedulingPolicy: TaskSchedulingPolicy
+ taskSlotsPerNode: int
+ upgradePolicy: UpgradePolicy
+ userAccounts: list[UserAccount]
+ vmSize: str
+ vmSkuProfile: VirtualMachineSkuProfile
+
+
+ class azure.mgmt.batch.types.PrivateEndpoint(TypedDict, total=False):
+ key "id": str
+ id: str
+
+
+ class azure.mgmt.batch.types.PrivateEndpointConnection(ProxyResource):
+ key "etag": str
+ key "id": str
+ key "name": str
+ key "properties": ForwardRef('PrivateEndpointConnectionProperties', module='types')
+ key "systemData": ForwardRef('SystemData', module='types')
+ key "type": str
+ etag: str
+ id: str
+ name: str
+ properties: PrivateEndpointConnectionProperties
+ systemData: SystemData
+ tags: dict[str, str]
+ type: str
+
+
+ class azure.mgmt.batch.types.PrivateEndpointConnectionProperties(TypedDict, total=False):
+ key "privateEndpoint": ForwardRef('PrivateEndpoint', module='types')
+ key "privateLinkServiceConnectionState": ForwardRef('PrivateLinkServiceConnectionState', module='types')
+ key "provisioningState": Union[str, PrivateEndpointConnectionProvisioningState]
+ groupIds: list[str]
+ privateEndpoint: PrivateEndpoint
+ privateLinkServiceConnectionState: PrivateLinkServiceConnectionState
+ provisioningState: Union[str, PrivateEndpointConnectionProvisioningState]
+
+
+ class azure.mgmt.batch.types.PrivateLinkServiceConnectionState(TypedDict, total=False):
+ key "actionsRequired": str
+ key "description": str
+ key "status": Required[Union[str, PrivateLinkServiceConnectionStatus]]
+ actionsRequired: str
+ description: str
+ status: Union[str, PrivateLinkServiceConnectionStatus]
+
+
+ class azure.mgmt.batch.types.ProxyAgentSettings(TypedDict, total=False):
+ key "enabled": bool
+ key "imds": ForwardRef('HostEndpointSettings', module='types')
+ key "wireServer": ForwardRef('HostEndpointSettings', module='types')
+ enabled: bool
+ imds: HostEndpointSettings
+ wireServer: HostEndpointSettings
+
+
+ class azure.mgmt.batch.types.ProxyResource(Resource):
+ key "id": str
+ key "name": str
+ key "systemData": ForwardRef('SystemData', module='types')
+ key "type": str
+ id: str
+ name: str
+ systemData: SystemData
+ type: str
+
+
+ class azure.mgmt.batch.types.PublicIPAddressConfiguration(TypedDict, total=False):
+ key "provision": Union[str, IPAddressProvisioningType]
+ ipAddressIds: list[str]
+ ipFamilies: list[Union[str, IPFamily]]
+ ipTags: list[IPTag]
+ provision: Union[str, IPAddressProvisioningType]
+
+
+ class azure.mgmt.batch.types.ResiliencyPolicy(TypedDict, total=False):
+ key "zoneAllocationPolicy": Required[ZoneAllocationPolicy]
+ zoneAllocationPolicy: ZoneAllocationPolicy
+
+
+ class azure.mgmt.batch.types.ResiliencyPolicyPatch(TypedDict, total=False):
+ key "zoneAllocationPolicy": ForwardRef('ZoneAllocationPolicyPatch', module='types')
+ zoneAllocationPolicy: ZoneAllocationPolicyPatch
+
+
+ class azure.mgmt.batch.types.ResizeError(TypedDict, total=False):
+ key "code": Required[str]
+ key "message": Required[str]
+ code: str
+ details: list[ResizeError]
+ message: str
+
+
+ class azure.mgmt.batch.types.ResizeOperationStatus(TypedDict, total=False):
+ key "nodeDeallocationOption": Union[str, ComputeNodeDeallocationOption]
+ key "resizeTimeout": str
+ key "startTime": str
+ key "targetDedicatedNodes": int
+ key "targetLowPriorityNodes": int
+ errors: list[ResizeError]
+ nodeDeallocationOption: Union[str, ComputeNodeDeallocationOption]
+ resizeTimeout: str
+ startTime: str
+ targetDedicatedNodes: int
+ targetLowPriorityNodes: int
+
+
+ class azure.mgmt.batch.types.Resource(TypedDict, total=False):
+ key "id": str
+ key "name": str
+ key "systemData": ForwardRef('SystemData', module='types')
+ key "type": str
+ id: str
+ name: str
+ systemData: SystemData
+ type: str
+
+
+ class azure.mgmt.batch.types.ResourceFile(TypedDict, total=False):
+ key "autoStorageContainerName": str
+ key "blobPrefix": str
+ key "fileMode": str
+ key "filePath": str
+ key "httpUrl": str
+ key "identityReference": ForwardRef('ComputeNodeIdentityReference', module='types')
+ key "storageContainerUrl": str
+ autoStorageContainerName: str
+ blobPrefix: str
+ fileMode: str
+ filePath: str
+ httpUrl: str
+ identityReference: ComputeNodeIdentityReference
+ storageContainerUrl: str
+
+
+ class azure.mgmt.batch.types.RollingUpgradePolicy(TypedDict, total=False):
+ key "enableCrossZoneUpgrade": bool
+ key "maxBatchInstancePercent": int
+ key "maxUnhealthyInstancePercent": int
+ key "maxUnhealthyUpgradedInstancePercent": int
+ key "pauseTimeBetweenBatches": str
+ key "prioritizeUnhealthyInstances": bool
+ key "rollbackFailedInstancesOnPolicyBreach": bool
+ enableCrossZoneUpgrade: bool
+ maxBatchInstancePercent: int
+ maxUnhealthyInstancePercent: int
+ maxUnhealthyUpgradedInstancePercent: int
+ pauseTimeBetweenBatches: str
+ prioritizeUnhealthyInstances: bool
+ rollbackFailedInstancesOnPolicyBreach: bool
+
+
+ class azure.mgmt.batch.types.ScaleSettings(TypedDict, total=False):
+ key "autoScale": ForwardRef('AutoScaleSettings', module='types')
+ key "fixedScale": ForwardRef('FixedScaleSettings', module='types')
+ autoScale: AutoScaleSettings
+ fixedScale: FixedScaleSettings
+
+
+ class azure.mgmt.batch.types.SecurityProfile(TypedDict, total=False):
+ key "encryptionAtHost": bool
+ key "proxyAgentSettings": ForwardRef('ProxyAgentSettings', module='types')
+ key "securityType": Union[str, SecurityTypes]
+ key "uefiSettings": ForwardRef('UefiSettings', module='types')
+ encryptionAtHost: bool
+ proxyAgentSettings: ProxyAgentSettings
+ securityType: Union[str, SecurityTypes]
+ uefiSettings: UefiSettings
+
+
+ class azure.mgmt.batch.types.ServiceArtifactReference(TypedDict, total=False):
+ key "id": Required[str]
+ id: str
+
+
+ class azure.mgmt.batch.types.StartTask(TypedDict, total=False):
+ key "commandLine": str
+ key "containerSettings": ForwardRef('TaskContainerSettings', module='types')
+ key "maxTaskRetryCount": int
+ key "userIdentity": ForwardRef('UserIdentity', module='types')
+ key "waitForSuccess": bool
+ commandLine: str
+ containerSettings: TaskContainerSettings
+ environmentSettings: list[EnvironmentSetting]
+ maxTaskRetryCount: int
+ resourceFiles: list[ResourceFile]
+ userIdentity: UserIdentity
+ waitForSuccess: bool
+
+
+ class azure.mgmt.batch.types.SystemData(TypedDict, total=False):
+ key "createdAt": str
+ key "createdBy": str
+ key "createdByType": Union[str, CreatedByType]
+ key "lastModifiedAt": str
+ key "lastModifiedBy": str
+ key "lastModifiedByType": Union[str, CreatedByType]
+ createdAt: str
+ createdBy: str
+ createdByType: Union[str, CreatedByType]
+ lastModifiedAt: str
+ lastModifiedBy: str
+ lastModifiedByType: Union[str, CreatedByType]
+
+
+ class azure.mgmt.batch.types.TaskContainerSettings(TypedDict, total=False):
+ key "containerRunOptions": str
+ key "imageName": Required[str]
+ key "registry": ForwardRef('ContainerRegistry', module='types')
+ key "workingDirectory": Union[str, ContainerWorkingDirectory]
+ containerHostBatchBindMounts: list[ContainerHostBatchBindMountEntry]
+ containerRunOptions: str
+ imageName: str
+ registry: ContainerRegistry
+ workingDirectory: Union[str, ContainerWorkingDirectory]
+
+
+ class azure.mgmt.batch.types.TaskSchedulingPolicy(TypedDict, total=False):
+ key "jobDefaultOrder": Union[str, JobDefaultOrder]
+ key "nodeFillType": Required[Union[str, ComputeNodeFillType]]
+ jobDefaultOrder: Union[str, JobDefaultOrder]
+ nodeFillType: Union[str, ComputeNodeFillType]
+
+
+ class azure.mgmt.batch.types.UefiSettings(TypedDict, total=False):
+ key "secureBootEnabled": bool
+ key "vTpmEnabled": bool
+ secureBootEnabled: bool
+ vTpmEnabled: bool
+
+
+ class azure.mgmt.batch.types.UpgradePolicy(TypedDict, total=False):
+ key "automaticOSUpgradePolicy": ForwardRef('AutomaticOSUpgradePolicy', module='types')
+ key "mode": Required[Union[str, UpgradeMode]]
+ key "rollingUpgradePolicy": ForwardRef('RollingUpgradePolicy', module='types')
+ automaticOSUpgradePolicy: AutomaticOSUpgradePolicy
+ mode: Union[str, UpgradeMode]
+ rollingUpgradePolicy: RollingUpgradePolicy
+
+
+ class azure.mgmt.batch.types.UserAccount(TypedDict, total=False):
+ key "elevationLevel": Union[str, ElevationLevel]
+ key "linuxUserConfiguration": ForwardRef('LinuxUserConfiguration', module='types')
+ key "name": Required[str]
+ key "password": Required[str]
+ key "windowsUserConfiguration": ForwardRef('WindowsUserConfiguration', module='types')
+ elevationLevel: Union[str, ElevationLevel]
+ linuxUserConfiguration: LinuxUserConfiguration
+ name: str
+ password: str
+ windowsUserConfiguration: WindowsUserConfiguration
+
+
+ class azure.mgmt.batch.types.UserAssignedIdentities(TypedDict, total=False):
+ key "clientId": str
+ key "principalId": str
+ clientId: str
+ principalId: str
+
+
+ class azure.mgmt.batch.types.UserIdentity(TypedDict, total=False):
+ key "autoUser": ForwardRef('AutoUserSpecification', module='types')
+ key "userName": str
+ autoUser: AutoUserSpecification
+ userName: str
+
+
+ class azure.mgmt.batch.types.VMDiskSecurityProfile(TypedDict, total=False):
+ key "diskEncryptionSet": ForwardRef('DiskEncryptionSetParameters', module='types')
+ key "securityEncryptionType": Union[str, SecurityEncryptionTypes]
+ diskEncryptionSet: DiskEncryptionSetParameters
+ securityEncryptionType: Union[str, SecurityEncryptionTypes]
+
+
+ class azure.mgmt.batch.types.VMExtension(TypedDict, total=False):
+ key "autoUpgradeMinorVersion": bool
+ key "enableAutomaticUpgrade": bool
+ key "name": Required[str]
+ key "protectedSettings": Any
+ key "publisher": Required[str]
+ key "settings": Any
+ key "type": Required[str]
+ key "typeHandlerVersion": str
+ autoUpgradeMinorVersion: bool
+ enableAutomaticUpgrade: bool
+ name: str
+ protectedSettings: Any
+ provisionAfterExtensions: list[str]
+ publisher: str
+ settings: Any
+ type: str
+ typeHandlerVersion: str
+
+
+ class azure.mgmt.batch.types.VirtualMachineConfiguration(TypedDict, total=False):
+ key "containerConfiguration": ForwardRef('ContainerConfiguration', module='types')
+ key "diskEncryptionConfiguration": ForwardRef('DiskEncryptionConfiguration', module='types')
+ key "hardwareProfile": ForwardRef('HardwareProfile', module='types')
+ key "imageReference": Required[ImageReference]
+ key "licenseType": str
+ key "nodeAgentSkuId": Required[str]
+ key "nodePlacementConfiguration": ForwardRef('NodePlacementConfiguration', module='types')
+ key "osDisk": ForwardRef('OSDisk', module='types')
+ key "placement": ForwardRef('Placement', module='types')
+ key "resiliencyPolicy": ForwardRef('ResiliencyPolicy', module='types')
+ key "securityProfile": ForwardRef('SecurityProfile', module='types')
+ key "serviceArtifactReference": ForwardRef('ServiceArtifactReference', module='types')
+ key "windowsConfiguration": ForwardRef('WindowsConfiguration', module='types')
+ containerConfiguration: ContainerConfiguration
+ dataDisks: list[DataDisk]
+ diskEncryptionConfiguration: DiskEncryptionConfiguration
+ extensions: list[VMExtension]
+ hardwareProfile: HardwareProfile
+ imageReference: ImageReference
+ licenseType: str
+ nodeAgentSkuId: str
+ nodePlacementConfiguration: NodePlacementConfiguration
+ osDisk: OSDisk
+ placement: Placement
+ resiliencyPolicy: ResiliencyPolicy
+ securityProfile: SecurityProfile
+ serviceArtifactReference: ServiceArtifactReference
+ windowsConfiguration: WindowsConfiguration
+
+
+ class azure.mgmt.batch.types.VirtualMachineConfigurationPatch(TypedDict, total=False):
+ key "containerConfiguration": ForwardRef('ContainerConfiguration', module='types')
+ key "diskEncryptionConfiguration": ForwardRef('DiskEncryptionConfiguration', module='types')
+ key "hardwareProfile": ForwardRef('HardwareProfile', module='types')
+ key "imageReference": Required[ImageReference]
+ key "licenseType": str
+ key "nodeAgentSkuId": Required[str]
+ key "nodePlacementConfiguration": ForwardRef('NodePlacementConfiguration', module='types')
+ key "osDisk": ForwardRef('OSDisk', module='types')
+ key "placement": ForwardRef('PlacementPatch', module='types')
+ key "resiliencyPolicy": ForwardRef('ResiliencyPolicyPatch', module='types')
+ key "securityProfile": ForwardRef('SecurityProfile', module='types')
+ key "serviceArtifactReference": ForwardRef('ServiceArtifactReference', module='types')
+ key "windowsConfiguration": ForwardRef('WindowsConfiguration', module='types')
+ containerConfiguration: ContainerConfiguration
+ dataDisks: list[DataDisk]
+ diskEncryptionConfiguration: DiskEncryptionConfiguration
+ extensions: list[VMExtension]
+ hardwareProfile: HardwareProfile
+ imageReference: ImageReference
+ licenseType: str
+ nodeAgentSkuId: str
+ nodePlacementConfiguration: NodePlacementConfiguration
+ osDisk: OSDisk
+ placement: PlacementPatch
+ resiliencyPolicy: ResiliencyPolicyPatch
+ securityProfile: SecurityProfile
+ serviceArtifactReference: ServiceArtifactReference
+ windowsConfiguration: WindowsConfiguration
+
+
+ class azure.mgmt.batch.types.VirtualMachineSkuProfile(TypedDict, total=False):
+ key "allocationStrategy": Union[str, VirtualMachineSkuAllocationStrategy]
+ allocationStrategy: Union[str, VirtualMachineSkuAllocationStrategy]
+ vmSizes: list[VirtualMachineSkuProfileVmSize]
+
+
+ class azure.mgmt.batch.types.VirtualMachineSkuProfileVmSize(TypedDict, total=False):
+ key "name": Required[str]
+ key "rank": int
+ name: str
+ rank: int
+
+
+ class azure.mgmt.batch.types.VmSizeProperties(TypedDict, total=False):
+ key "vCPUsAvailable": int
+ key "vCPUsPerCore": int
+ vCPUsAvailable: int
+ vCPUsPerCore: int
+
+
+ class azure.mgmt.batch.types.WindowsConfiguration(TypedDict, total=False):
+ key "enableAutomaticUpdates": bool
+ enableAutomaticUpdates: bool
+
+
+ class azure.mgmt.batch.types.WindowsUserConfiguration(TypedDict, total=False):
+ key "loginMode": Union[str, LoginMode]
+ loginMode: Union[str, LoginMode]
+
+
+ class azure.mgmt.batch.types.ZoneAllocationPolicy(TypedDict, total=False):
+ key "maxInstancePercentPerZonePolicy": ForwardRef('MaxInstancePercentPerZonePolicy', module='types')
+ key "maxZoneCount": int
+ maxInstancePercentPerZonePolicy: MaxInstancePercentPerZonePolicy
+ maxZoneCount: int
+
+
+ class azure.mgmt.batch.types.ZoneAllocationPolicyPatch(TypedDict, total=False):
+ key "maxInstancePercentPerZonePolicy": ForwardRef('MaxInstancePercentPerZonePolicyPatch', module='types')
+ key "maxZoneCount": int
+ maxInstancePercentPerZonePolicy: MaxInstancePercentPerZonePolicyPatch
+ maxZoneCount: int
+
+
+```
\ No newline at end of file
diff --git a/sdk/batch/azure-mgmt-batch/api.metadata.yml b/sdk/batch/azure-mgmt-batch/api.metadata.yml
new file mode 100644
index 000000000000..2c531d465154
--- /dev/null
+++ b/sdk/batch/azure-mgmt-batch/api.metadata.yml
@@ -0,0 +1,4 @@
+apiHash: 8290e7e3e8621cbeace52495db31d9930283c6313a7bbaf863803a0382492e5d
+packageVersion: 20.0.0
+parserVersion: 0.3.31
+pythonVersion: 3.13.18
diff --git a/sdk/batch/azure-mgmt-batch/apiview-properties.json b/sdk/batch/azure-mgmt-batch/apiview-properties.json
index 90dafc78b203..582461c0d6c7 100644
--- a/sdk/batch/azure-mgmt-batch/apiview-properties.json
+++ b/sdk/batch/azure-mgmt-batch/apiview-properties.json
@@ -21,7 +21,7 @@
"azure.mgmt.batch.models.AutoUserSpecification": "Microsoft.Batch.AutoUserSpecification",
"azure.mgmt.batch.models.AzureBlobFileSystemConfiguration": "Microsoft.Batch.AzureBlobFileSystemConfiguration",
"azure.mgmt.batch.models.AzureFileShareConfiguration": "Microsoft.Batch.AzureFileShareConfiguration",
- "azure.mgmt.batch.models.AzureResource": "Azure.ResourceManager.CommonTypes.TrackedResource",
+ "azure.mgmt.batch.models.TrackedResource": "Azure.ResourceManager.CommonTypes.TrackedResource",
"azure.mgmt.batch.models.BatchAccount": "Microsoft.Batch.BatchAccount",
"azure.mgmt.batch.models.BatchAccountCreateParameters": "Microsoft.Batch.BatchAccountCreateParameters",
"azure.mgmt.batch.models.BatchAccountCreateProperties": "Microsoft.Batch.BatchAccountCreateProperties",
@@ -44,6 +44,7 @@
"azure.mgmt.batch.models.ContainerRegistry": "Microsoft.Batch.ContainerRegistry",
"azure.mgmt.batch.models.DataDisk": "Microsoft.Batch.DataDisk",
"azure.mgmt.batch.models.DeploymentConfiguration": "Microsoft.Batch.DeploymentConfiguration",
+ "azure.mgmt.batch.models.DeploymentConfigurationPatch": "Microsoft.Batch.DeploymentConfigurationPatch",
"azure.mgmt.batch.models.DetectorResponse": "Microsoft.Batch.DetectorResponse",
"azure.mgmt.batch.models.DetectorResponseProperties": "Microsoft.Batch.DetectorResponseProperties",
"azure.mgmt.batch.models.DiffDiskSettings": "Microsoft.Batch.DiffDiskSettings",
@@ -59,6 +60,7 @@
"azure.mgmt.batch.models.ErrorDetail": "Azure.ResourceManager.CommonTypes.ErrorDetail",
"azure.mgmt.batch.models.ErrorResponse": "Azure.ResourceManager.CommonTypes.ErrorResponse",
"azure.mgmt.batch.models.FixedScaleSettings": "Microsoft.Batch.FixedScaleSettings",
+ "azure.mgmt.batch.models.HardwareProfile": "Microsoft.Batch.HardwareProfile",
"azure.mgmt.batch.models.HostEndpointSettings": "Microsoft.Batch.HostEndpointSettings",
"azure.mgmt.batch.models.ImageReference": "Microsoft.Batch.ImageReference",
"azure.mgmt.batch.models.InboundNatPool": "Microsoft.Batch.InboundNatPool",
@@ -68,13 +70,15 @@
"azure.mgmt.batch.models.KeyVaultReference": "Microsoft.Batch.KeyVaultReference",
"azure.mgmt.batch.models.LinuxUserConfiguration": "Microsoft.Batch.LinuxUserConfiguration",
"azure.mgmt.batch.models.ManagedDisk": "Microsoft.Batch.ManagedDisk",
+ "azure.mgmt.batch.models.MaxInstancePercentPerZonePolicy": "Microsoft.Batch.MaxInstancePercentPerZonePolicy",
+ "azure.mgmt.batch.models.MaxInstancePercentPerZonePolicyPatch": "Microsoft.Batch.MaxInstancePercentPerZonePolicyPatch",
"azure.mgmt.batch.models.MetadataItem": "Microsoft.Batch.MetadataItem",
"azure.mgmt.batch.models.MountConfiguration": "Microsoft.Batch.MountConfiguration",
"azure.mgmt.batch.models.NetworkConfiguration": "Microsoft.Batch.NetworkConfiguration",
"azure.mgmt.batch.models.NetworkProfile": "Microsoft.Batch.NetworkProfile",
"azure.mgmt.batch.models.NetworkSecurityGroupRule": "Microsoft.Batch.NetworkSecurityGroupRule",
"azure.mgmt.batch.models.NetworkSecurityPerimeter": "Azure.ResourceManager.CommonTypes.NetworkSecurityPerimeter",
- "azure.mgmt.batch.models.NetworkSecurityPerimeterConfiguration": "Azure.ResourceManager.CommonTypes.NetworkSecurityPerimeterConfiguration",
+ "azure.mgmt.batch.models.NetworkSecurityPerimeterConfiguration": "Microsoft.Batch.NetworkSecurityPerimeterConfiguration",
"azure.mgmt.batch.models.NetworkSecurityPerimeterConfigurationProperties": "Azure.ResourceManager.CommonTypes.NetworkSecurityPerimeterConfigurationProperties",
"azure.mgmt.batch.models.NetworkSecurityProfile": "Azure.ResourceManager.CommonTypes.NetworkSecurityProfile",
"azure.mgmt.batch.models.NFSMountConfiguration": "Microsoft.Batch.NFSMountConfiguration",
@@ -83,8 +87,12 @@
"azure.mgmt.batch.models.OperationDisplay": "Microsoft.Batch.OperationDisplay",
"azure.mgmt.batch.models.OSDisk": "Microsoft.Batch.OSDisk",
"azure.mgmt.batch.models.OutboundEnvironmentEndpoint": "Microsoft.Batch.OutboundEnvironmentEndpoint",
+ "azure.mgmt.batch.models.Placement": "Microsoft.Batch.Placement",
+ "azure.mgmt.batch.models.PlacementPatch": "Microsoft.Batch.PlacementPatch",
"azure.mgmt.batch.models.Pool": "Microsoft.Batch.Pool",
"azure.mgmt.batch.models.PoolEndpointConfiguration": "Microsoft.Batch.PoolEndpointConfiguration",
+ "azure.mgmt.batch.models.PoolPatch": "Microsoft.Batch.PoolPatch",
+ "azure.mgmt.batch.models.PoolPatchProperties": "Microsoft.Batch.PoolPatchProperties",
"azure.mgmt.batch.models.PoolProperties": "Microsoft.Batch.PoolProperties",
"azure.mgmt.batch.models.PrivateEndpoint": "Microsoft.Batch.PrivateEndpoint",
"azure.mgmt.batch.models.PrivateEndpointConnection": "Microsoft.Batch.PrivateEndpointConnection",
@@ -96,6 +104,8 @@
"azure.mgmt.batch.models.ProvisioningIssueProperties": "Azure.ResourceManager.CommonTypes.ProvisioningIssueProperties",
"azure.mgmt.batch.models.ProxyAgentSettings": "Microsoft.Batch.ProxyAgentSettings",
"azure.mgmt.batch.models.PublicIPAddressConfiguration": "Microsoft.Batch.PublicIPAddressConfiguration",
+ "azure.mgmt.batch.models.ResiliencyPolicy": "Microsoft.Batch.ResiliencyPolicy",
+ "azure.mgmt.batch.models.ResiliencyPolicyPatch": "Microsoft.Batch.ResiliencyPolicyPatch",
"azure.mgmt.batch.models.ResizeError": "Microsoft.Batch.ResizeError",
"azure.mgmt.batch.models.ResizeOperationStatus": "Microsoft.Batch.ResizeOperationStatus",
"azure.mgmt.batch.models.ResourceAssociation": "Azure.ResourceManager.CommonTypes.ResourceAssociation",
@@ -116,11 +126,17 @@
"azure.mgmt.batch.models.UserAssignedIdentities": "Microsoft.Batch.UserAssignedIdentities",
"azure.mgmt.batch.models.UserIdentity": "Microsoft.Batch.UserIdentity",
"azure.mgmt.batch.models.VirtualMachineConfiguration": "Microsoft.Batch.VirtualMachineConfiguration",
+ "azure.mgmt.batch.models.VirtualMachineConfigurationPatch": "Microsoft.Batch.VirtualMachineConfigurationPatch",
"azure.mgmt.batch.models.VirtualMachineFamilyCoreQuota": "Microsoft.Batch.VirtualMachineFamilyCoreQuota",
+ "azure.mgmt.batch.models.VirtualMachineSkuProfile": "Microsoft.Batch.VirtualMachineSkuProfile",
+ "azure.mgmt.batch.models.VirtualMachineSkuProfileVmSize": "Microsoft.Batch.VirtualMachineSkuProfileVmSize",
"azure.mgmt.batch.models.VMDiskSecurityProfile": "Microsoft.Batch.VMDiskSecurityProfile",
"azure.mgmt.batch.models.VMExtension": "Microsoft.Batch.VMExtension",
+ "azure.mgmt.batch.models.VmSizeProperties": "Microsoft.Batch.VmSizeProperties",
"azure.mgmt.batch.models.WindowsConfiguration": "Microsoft.Batch.WindowsConfiguration",
"azure.mgmt.batch.models.WindowsUserConfiguration": "Microsoft.Batch.WindowsUserConfiguration",
+ "azure.mgmt.batch.models.ZoneAllocationPolicy": "Microsoft.Batch.ZoneAllocationPolicy",
+ "azure.mgmt.batch.models.ZoneAllocationPolicyPatch": "Microsoft.Batch.ZoneAllocationPolicyPatch",
"azure.mgmt.batch.models.CreatedByType": "Azure.ResourceManager.CommonTypes.createdByType",
"azure.mgmt.batch.models.ProvisioningState": "Microsoft.Batch.ProvisioningState",
"azure.mgmt.batch.models.PoolAllocationMode": "Microsoft.Batch.PoolAllocationMode",
@@ -137,6 +153,7 @@
"azure.mgmt.batch.models.PackageState": "Microsoft.Batch.PackageState",
"azure.mgmt.batch.models.PoolProvisioningState": "Microsoft.Batch.PoolProvisioningState",
"azure.mgmt.batch.models.AllocationState": "Microsoft.Batch.AllocationState",
+ "azure.mgmt.batch.models.VirtualMachineSkuAllocationStrategy": "Microsoft.Batch.VirtualMachineSkuAllocationStrategy",
"azure.mgmt.batch.models.CachingType": "Microsoft.Batch.CachingType",
"azure.mgmt.batch.models.StorageAccountType": "Microsoft.Batch.StorageAccountType",
"azure.mgmt.batch.models.SecurityEncryptionTypes": "Microsoft.Batch.SecurityEncryptionTypes",
@@ -146,7 +163,8 @@
"azure.mgmt.batch.models.DiffDiskPlacement": "Microsoft.Batch.DiffDiskPlacement",
"azure.mgmt.batch.models.SecurityTypes": "Microsoft.Batch.SecurityTypes",
"azure.mgmt.batch.models.HostEndpointSettingsModeTypes": "Microsoft.Batch.HostEndpointSettingsModeTypes",
- "azure.mgmt.batch.models.ComputeNodeDeallocationOption": "Microsoft.Batch.ComputeNodeDeallocationOption",
+ "azure.mgmt.batch.models.ZonePlacementPolicyType": "Microsoft.Batch.ZonePlacementPolicyType",
+ "azure.mgmt.batch.models.RequestedComputeNodeDeallocationOption": "Microsoft.Batch.RequestedComputeNodeDeallocationOption",
"azure.mgmt.batch.models.InterNodeCommunicationState": "Microsoft.Batch.InterNodeCommunicationState",
"azure.mgmt.batch.models.DynamicVNetAssignmentScope": "Microsoft.Batch.DynamicVNetAssignmentScope",
"azure.mgmt.batch.models.InboundEndpointProtocol": "Microsoft.Batch.InboundEndpointProtocol",
@@ -160,6 +178,7 @@
"azure.mgmt.batch.models.AutoUserScope": "Microsoft.Batch.AutoUserScope",
"azure.mgmt.batch.models.ContainerWorkingDirectory": "Microsoft.Batch.ContainerWorkingDirectory",
"azure.mgmt.batch.models.ContainerHostDataPath": "Microsoft.Batch.ContainerHostDataPath",
+ "azure.mgmt.batch.models.ComputeNodeDeallocationOption": "Microsoft.Batch.ComputeNodeDeallocationOption",
"azure.mgmt.batch.models.UpgradeMode": "Microsoft.Batch.UpgradeMode",
"azure.mgmt.batch.models.PoolIdentityType": "Microsoft.Batch.PoolIdentityType",
"azure.mgmt.batch.models.NetworkSecurityPerimeterConfigurationProvisioningState": "Azure.ResourceManager.CommonTypes.NetworkSecurityPerimeterConfigurationProvisioningState",
@@ -253,5 +272,6 @@
"azure.mgmt.batch.aio.operations.LocationOperations.list_supported_virtual_machine_skus": "Microsoft.Batch.LocationOperationGroup.listSupportedVirtualMachineSkus",
"azure.mgmt.batch.operations.LocationOperations.check_name_availability": "Microsoft.Batch.LocationOperationGroup.checkNameAvailability",
"azure.mgmt.batch.aio.operations.LocationOperations.check_name_availability": "Microsoft.Batch.LocationOperationGroup.checkNameAvailability"
- }
+ },
+ "CrossLanguageVersion": "5ad8fd654333"
}
\ No newline at end of file
diff --git a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_client.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_client.py
index 2db4a28d73f6..bd8167ef63d5 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_client.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_client.py
@@ -7,8 +7,8 @@
# --------------------------------------------------------------------------
from copy import deepcopy
+import sys
from typing import Any, Optional, TYPE_CHECKING, cast
-from typing_extensions import Self
from azure.core.pipeline import policies
from azure.core.rest import HttpRequest, HttpResponse
@@ -31,13 +31,18 @@
PrivateLinkResourceOperations,
)
+if sys.version_info >= (3, 11):
+ from typing import Self
+else:
+ from typing_extensions import Self # type: ignore
+
if TYPE_CHECKING:
from azure.core import AzureClouds
from azure.core.credentials import TokenCredential
-class BatchManagementClient: # pylint: disable=too-many-instance-attributes
- """The Batch Management Client.
+class BatchManagementClient: # pylint: disable=too-many-instance-attributes,docstring-keyword-should-match-keyword-only
+ """BatchManagementClient.
:ivar operations: Operations operations
:vartype operations: azure.mgmt.batch.operations.Operations
@@ -68,7 +73,8 @@ class BatchManagementClient: # pylint: disable=too-many-instance-attributes
:keyword cloud_setting: The cloud setting for which to get the ARM endpoint. Default value is
None.
:paramtype cloud_setting: ~azure.core.AzureClouds
- :keyword api_version: The API version to use for this operation. Default value is "2025-06-01".
+ :keyword api_version: The API version to use for this operation. Known values are "2026-10-01"
+ and None. Default value is None. If not set, the operation's default API version will be used.
Note that overriding this default value may result in unsupported behavior.
:paramtype api_version: str
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no
diff --git a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_configuration.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_configuration.py
index 70c0d71a4663..9573c5a16c3b 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_configuration.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_configuration.py
@@ -1,3 +1,4 @@
+# pylint: disable=line-too-long,useless-suppression
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
@@ -18,7 +19,7 @@
from azure.core.credentials import TokenCredential
-class BatchManagementClientConfiguration: # pylint: disable=too-many-instance-attributes
+class BatchManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,docstring-keyword-should-match-keyword-only
"""Configuration for BatchManagementClient.
Note that all parameters used to create this instance are saved as instance
@@ -33,7 +34,8 @@ class BatchManagementClientConfiguration: # pylint: disable=too-many-instance-a
:param cloud_setting: The cloud setting for which to get the ARM endpoint. Default value is
None.
:type cloud_setting: ~azure.core.AzureClouds
- :keyword api_version: The API version to use for this operation. Default value is "2025-06-01".
+ :keyword api_version: The API version to use for this operation. Known values are "2026-10-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
"""
@@ -46,7 +48,7 @@ def __init__(
cloud_setting: Optional["AzureClouds"] = None,
**kwargs: Any
) -> None:
- api_version: str = kwargs.pop("api_version", "2025-06-01")
+ api_version: str = kwargs.pop("api_version", "2026-10-01")
if credential is None:
raise ValueError("Parameter 'credential' must not be None.")
diff --git a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_patch.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_patch.py
index 87676c65a8f0..ea765788358a 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_patch.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_patch.py
@@ -8,7 +8,6 @@
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/batch/azure-mgmt-batch/azure/mgmt/batch/_utils/model_base.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_utils/model_base.py
index c402af2afc63..35d5fc024978 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_utils/model_base.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_utils/model_base.py
@@ -23,14 +23,19 @@
from json import JSONEncoder
import xml.etree.ElementTree as ET
from collections.abc import MutableMapping
-from typing_extensions import Self
import isodate
from azure.core.exceptions import DeserializationError
from azure.core import CaseInsensitiveEnumMeta
from azure.core.pipeline import PipelineResponse
from azure.core.serialization import _Null
+
from azure.core.rest import HttpResponse
+if sys.version_info >= (3, 11):
+ from typing import Self
+else:
+ from typing_extensions import Self
+
_LOGGER = logging.getLogger(__name__)
__all__ = ["SdkJSONEncoder", "Model", "rest_field", "rest_discriminator"]
@@ -104,6 +109,29 @@ def _serialize_bytes(o, format: typing.Optional[str] = None) -> str:
return encoded
+def _serialize_duration(td: timedelta, format: typing.Optional[str] = None):
+ """Serialize a timedelta to its wire representation.
+
+ For the ``seconds``/``milliseconds`` encodings the value is converted to a
+ numeric value, otherwise it falls back to an ISO 8601 duration string.
+
+ :param timedelta td: The timedelta to serialize.
+ :param str format: The duration encoding format.
+ :rtype: int or float or str
+ :return: serialized duration
+ """
+ seconds = td.total_seconds()
+ if format == "duration-seconds-int":
+ return int(seconds)
+ if format == "duration-seconds-float":
+ return seconds
+ if format == "duration-milliseconds-int":
+ return int(seconds * 1000)
+ if format == "duration-milliseconds-float":
+ return seconds * 1000
+ return _timedelta_as_isostr(td)
+
+
def _serialize_datetime(o, format: typing.Optional[str] = None):
if hasattr(o, "year") and hasattr(o, "hour"):
if format == "rfc7231":
@@ -130,7 +158,15 @@ def _is_readonly(p):
class SdkJSONEncoder(JSONEncoder):
- """A JSON encoder that's capable of serializing datetime objects and bytes."""
+ """A JSON encoder that's capable of serializing datetime objects and bytes.
+
+ :param args: Additional positional arguments passed to the base ``JSONEncoder``.
+ :type args: typing.Any
+ :keyword exclude_readonly: Whether to exclude readonly properties. Defaults to False.
+ :paramtype exclude_readonly: bool
+ :keyword format: The format to use for serialization. Defaults to None.
+ :paramtype format: typing.Optional[str]
+ """
def __init__(self, *args, exclude_readonly: bool = False, format: typing.Optional[str] = None, **kwargs):
super().__init__(*args, **kwargs)
@@ -296,6 +332,12 @@ def _deserialize_duration(attr):
return isodate.parse_duration(attr)
+def _deserialize_duration_numeric(attr, unit):
+ if isinstance(attr, timedelta):
+ return attr
+ return timedelta(**{unit: float(attr)})
+
+
def _deserialize_decimal(attr):
if isinstance(attr, decimal.Decimal):
return attr
@@ -308,6 +350,12 @@ def _deserialize_int_as_str(attr):
return int(attr)
+def _deserialize_bool_as_str(attr):
+ if isinstance(attr, bool):
+ return attr
+ return attr.lower() == "true"
+
+
_DESERIALIZE_MAPPING = {
datetime: _deserialize_datetime,
date: _deserialize_date,
@@ -325,12 +373,18 @@ def _deserialize_int_as_str(attr):
"unix-timestamp": _deserialize_datetime_unix_timestamp,
"base64": _deserialize_bytes,
"base64url": _deserialize_bytes_base64,
+ "duration-seconds-int": functools.partial(_deserialize_duration_numeric, unit="seconds"),
+ "duration-seconds-float": functools.partial(_deserialize_duration_numeric, unit="seconds"),
+ "duration-milliseconds-int": functools.partial(_deserialize_duration_numeric, unit="milliseconds"),
+ "duration-milliseconds-float": functools.partial(_deserialize_duration_numeric, unit="milliseconds"),
}
def get_deserializer(annotation: typing.Any, rf: typing.Optional["_RestField"] = None):
if annotation is int and rf and rf._format == "str":
return _deserialize_int_as_str
+ if annotation is bool and rf and rf._format == "str":
+ return _deserialize_bool_as_str
if annotation is str and rf and rf._format in _ARRAY_ENCODE_MAPPING:
return functools.partial(_deserialize_array_encoded, _ARRAY_ENCODE_MAPPING[rf._format])
if rf and rf._format:
@@ -420,21 +474,21 @@ def __ne__(self, other: typing.Any) -> bool:
def keys(self) -> typing.KeysView[str]:
"""
- :returns: a set-like object providing a view on D's keys
+ :returns: a set-like object providing a view on the mapping's keys
:rtype: ~typing.KeysView
"""
return self._data.keys()
def values(self) -> typing.ValuesView[typing.Any]:
"""
- :returns: an object providing a view on D's values
+ :returns: an object providing a view on the mapping's values
:rtype: ~typing.ValuesView
"""
return self._data.values()
def items(self) -> typing.ItemsView[str, typing.Any]:
"""
- :returns: set-like object providing a view on D's items
+ :returns: a set-like object providing a view on the mapping's items
:rtype: ~typing.ItemsView
"""
return self._data.items()
@@ -444,7 +498,7 @@ def get(self, key: str, default: typing.Any = None) -> typing.Any:
Get the value for key if key is in the dictionary, else default.
:param str key: The key to look up.
:param any default: The value to return if key is not in the dictionary. Defaults to None
- :returns: D[k] if k in D, else d.
+ :returns: The value for key if key is in the dictionary, else default.
:rtype: any
"""
try:
@@ -479,19 +533,19 @@ def popitem(self) -> tuple[str, typing.Any]:
Removes and returns some (key, value) pair
:returns: The (key, value) pair.
:rtype: tuple
- :raises KeyError: if D is empty.
+ :raises KeyError: if the dictionary is empty.
"""
return self._data.popitem()
def clear(self) -> None:
"""
- Remove all items from D.
+ Remove all items from the dictionary.
"""
self._data.clear()
def update(self, *args: typing.Any, **kwargs: typing.Any) -> None: # pylint: disable=arguments-differ
"""
- Updates D from mapping/iterable E and F.
+ Update the dictionary from a mapping or an iterable of key-value pairs.
:param any args: Either a mapping object or an iterable of key-value pairs.
"""
self._data.update(*args, **kwargs)
@@ -504,10 +558,11 @@ def setdefault(self, key: str, default: typing.Any) -> typing.Any: ... # pylint
def setdefault(self, key: str, default: typing.Any = _UNSET) -> typing.Any:
"""
- Same as calling D.get(k, d), and setting D[k]=d if k not found
+ Return the value for key if key is in the dictionary; otherwise set the key to
+ default and return default.
:param str key: The key to look up.
:param any default: The value to set if key is not in the dictionary
- :returns: D[k] if k in D, else d.
+ :returns: The value for key if key is in the dictionary, else default.
:rtype: any
"""
if default is _UNSET:
@@ -515,6 +570,8 @@ def setdefault(self, key: str, default: typing.Any = _UNSET) -> typing.Any:
return self._data.setdefault(key, default)
def __eq__(self, other: typing.Any) -> bool:
+ if isinstance(other, _MyMutableMapping):
+ return self._data == other._data
try:
other_model = self.__class__(other)
except Exception:
@@ -557,7 +614,7 @@ def _serialize(o, format: typing.Optional[str] = None): # pylint: disable=too-m
pass
# Last, try datetime.timedelta
try:
- return _timedelta_as_isostr(o)
+ return _serialize_duration(o, format)
except AttributeError:
# This will be raised when it hits value.total_seconds in the method above
pass
@@ -583,6 +640,239 @@ def _create_value(rf: typing.Optional["_RestField"], value: typing.Any) -> typin
return _serialize(value, rf._format)
+# ============================================================================
+# Fast-path scalar deserializer functions for rest_field(deserializer=...)
+# These are referenced from rest_field declarations to bypass the generic
+# _deserialize -> _deserialize_with_callable chain.
+# Only simple/primitive types — no models or container types.
+# ============================================================================
+
+
+def _xml_deser_str(value):
+ if isinstance(value, ET.Element):
+ return value.text or ""
+ return str(value) if value is not None else None
+
+
+def _xml_deser_int(value):
+ if isinstance(value, ET.Element):
+ return int(value.text) if value.text else None
+ return int(value) if value is not None else None
+
+
+def _xml_deser_float(value):
+ if isinstance(value, ET.Element):
+ return float(value.text) if value.text else None
+ return float(value) if value is not None else None
+
+
+def _xml_deser_bool(value):
+ if isinstance(value, ET.Element):
+ text = value.text
+ else:
+ text = value
+ if text is None:
+ return None
+ if text in (True, False):
+ return text
+ return text.lower() == "true"
+
+
+# pylint: disable=docstring-missing-param
+def _xml_deser_bytes(value):
+ """Deserialize bytes from XML (base64)."""
+ if isinstance(value, ET.Element):
+ text = value.text
+ else:
+ text = value
+ if text is None:
+ return None
+ return _deserialize_bytes(text)
+
+
+def _xml_deser_bytes_base64url(value):
+ """Deserialize bytes from XML (base64url)."""
+ if isinstance(value, ET.Element):
+ text = value.text
+ else:
+ text = value
+ if text is None:
+ return None
+ return _deserialize_bytes_base64(text)
+
+
+def _xml_deser_datetime(value):
+ """Deserialize a datetime from XML (ISO 8601 / rfc3339)."""
+ if isinstance(value, ET.Element):
+ text = value.text
+ else:
+ text = value
+ if text is None:
+ return None
+ return _deserialize_datetime(text)
+
+
+def _xml_deser_datetime_rfc7231(value):
+ """Deserialize a datetime from XML (RFC7231 format)."""
+ if isinstance(value, ET.Element):
+ text = value.text
+ else:
+ text = value
+ if text is None:
+ return None
+ return _deserialize_datetime_rfc7231(text)
+
+
+def _xml_deser_datetime_unix_timestamp(value):
+ """Deserialize a datetime from XML (Unix timestamp)."""
+ if isinstance(value, ET.Element):
+ text = value.text
+ else:
+ text = value
+ if text is None:
+ return None
+ return _deserialize_datetime_unix_timestamp(float(text))
+
+
+def _xml_deser_date(value):
+ """Deserialize a date from XML (ISO 8601)."""
+ if isinstance(value, ET.Element):
+ text = value.text
+ else:
+ text = value
+ if text is None:
+ return None
+ return _deserialize_date(text)
+
+
+def _xml_deser_time(value):
+ """Deserialize a time from XML (ISO 8601)."""
+ if isinstance(value, ET.Element):
+ text = value.text
+ else:
+ text = value
+ if text is None:
+ return None
+ return _deserialize_time(text)
+
+
+def _xml_deser_duration(value):
+ """Deserialize a timedelta from XML (ISO 8601 duration)."""
+ if isinstance(value, ET.Element):
+ text = value.text
+ else:
+ text = value
+ if text is None:
+ return None
+ return _deserialize_duration(text)
+
+
+def _xml_deser_decimal(value):
+ """Deserialize a Decimal from XML."""
+ if isinstance(value, ET.Element):
+ text = value.text
+ else:
+ text = value
+ if text is None:
+ return None
+ return _deserialize_decimal(text)
+
+
+def _xml_deser_enum_or_str(enum_cls, value):
+ """Deserialize a Union[EnumType, str] from XML."""
+ text = value.text if isinstance(value, ET.Element) else value
+ if text is None:
+ return None
+ try:
+ return enum_cls(text)
+ except ValueError:
+ return text
+
+
+def _extract_xml_model_type(rf_type):
+ """Extract the concrete Model class from a resolved rf._type partial chain.
+
+ Unwraps ``Optional[Model]`` and ``_deserialize_model(Model, ...)``
+ wrappers. Only handles Model and Optional[Model] — other composite
+ types (List, Dict, Union, etc.) return None and fall through to the
+ generic ``_deserialize`` path at runtime.
+ """
+ if rf_type is None:
+ return None
+ if isinstance(rf_type, type) and _is_model(rf_type):
+ return rf_type
+ if not isinstance(rf_type, functools.partial):
+ return None
+ func = rf_type.func
+ args = rf_type.args
+ if func is _deserialize_with_optional and args:
+ return _extract_xml_model_type(args[0])
+ if func is _deserialize_model and args:
+ cls = args[0]
+ return cls if isinstance(cls, type) and _is_model(cls) else None
+ return None
+
+
+def _build_xml_field_plan( # pylint: disable=docstring-missing-return, docstring-missing-rtype, unused-variable
+ cls, attr_to_rest_field: dict
+) -> list:
+ """Build a precomputed XML field plan for fast _init_from_xml iteration.
+
+ Called once per model class in __new__. Returns a list of tuples:
+ (rest_name, xml_name, kind, deser, rf_type, is_optional, items_name)
+
+ kind: 0=wrapped, 1=attribute, 2=unwrapped, 3=text
+
+ For Model and Optional[Model] fields that lack a scalar
+ ``_deserializer``, this function precomputes the Model class as the
+ deserializer so ``_init_from_xml`` can call ``ModelClass(element)``
+ directly instead of going through the expensive
+ ``_get_deserialize_callable_from_annotation`` chain at runtime.
+ """
+ model_meta = getattr(cls, "_xml", {})
+ model_ns = model_meta.get("ns") or model_meta.get("namespace")
+ plan = []
+
+ for rf in attr_to_rest_field.values():
+ prop_meta = getattr(rf, "_xml", {})
+ deser = rf._deserializer
+
+ xml_name = prop_meta.get("name", rf._rest_name)
+ xml_ns = _resolve_xml_ns(prop_meta, model_meta)
+ if xml_ns:
+ xml_name = "{" + xml_ns + "}" + xml_name
+
+ is_optional = rf._is_optional
+
+ # For Model / Optional[Model] fields without a scalar deserializer,
+ # precompute the Model class as the deserializer.
+ if deser is None and rf._type is not None:
+ model_cls = _extract_xml_model_type(rf._type)
+ if model_cls is not None:
+ deser = model_cls
+
+ if prop_meta.get("attribute", False):
+ plan.append((rf._rest_name, xml_name, 1, deser, rf._type, is_optional, None))
+ elif prop_meta.get("unwrapped", False):
+ items_name = prop_meta.get("itemsName")
+ if items_name:
+ items_ns = prop_meta.get("itemsNs")
+ if items_ns is not None:
+ xml_ns = items_ns
+ if xml_ns:
+ items_name = "{" + xml_ns + "}" + items_name
+ else:
+ items_name = xml_name
+ plan.append((rf._rest_name, xml_name, 2, deser, rf._type, is_optional, items_name))
+ elif prop_meta.get("text", False):
+ plan.append((rf._rest_name, xml_name, 3, deser, rf._type, is_optional, None))
+ else:
+ plan.append((rf._rest_name, xml_name, 0, deser, rf._type, is_optional, None))
+
+ return plan
+
+
+# pylint: enable=docstring-missing-param
class Model(_MyMutableMapping):
_is_model = True
# label whether current class's _attr_to_rest_field has been calculated
@@ -593,59 +883,10 @@ def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
class_name = self.__class__.__name__
if len(args) > 1:
raise TypeError(f"{class_name}.__init__() takes 2 positional arguments but {len(args) + 1} were given")
- dict_to_pass = {
- rest_field._rest_name: rest_field._default
- for rest_field in self._attr_to_rest_field.values()
- if rest_field._default is not _UNSET
- }
- if args: # pylint: disable=too-many-nested-blocks
+ dict_to_pass: dict[str, typing.Any] = {}
+ if args:
if isinstance(args[0], ET.Element):
- existed_attr_keys = []
- model_meta = getattr(self, "_xml", {})
-
- for rf in self._attr_to_rest_field.values():
- prop_meta = getattr(rf, "_xml", {})
- xml_name = prop_meta.get("name", rf._rest_name)
- xml_ns = prop_meta.get("ns", model_meta.get("ns", None))
- if xml_ns:
- xml_name = "{" + xml_ns + "}" + xml_name
-
- # attribute
- if prop_meta.get("attribute", False) and args[0].get(xml_name) is not None:
- existed_attr_keys.append(xml_name)
- dict_to_pass[rf._rest_name] = _deserialize(rf._type, args[0].get(xml_name))
- continue
-
- # unwrapped element is array
- if prop_meta.get("unwrapped", False):
- # unwrapped array could either use prop items meta/prop meta
- if prop_meta.get("itemsName"):
- xml_name = prop_meta.get("itemsName")
- xml_ns = prop_meta.get("itemNs")
- if xml_ns:
- xml_name = "{" + xml_ns + "}" + xml_name
- items = args[0].findall(xml_name) # pyright: ignore
- if len(items) > 0:
- existed_attr_keys.append(xml_name)
- dict_to_pass[rf._rest_name] = _deserialize(rf._type, items)
- continue
-
- # text element is primitive type
- if prop_meta.get("text", False):
- if args[0].text is not None:
- dict_to_pass[rf._rest_name] = _deserialize(rf._type, args[0].text)
- continue
-
- # wrapped element could be normal property or array, it should only have one element
- item = args[0].find(xml_name)
- if item is not None:
- existed_attr_keys.append(xml_name)
- dict_to_pass[rf._rest_name] = _deserialize(rf._type, item)
-
- # rest thing is additional properties
- for e in args[0]:
- if e.tag not in existed_attr_keys:
- dict_to_pass[e.tag] = _convert_element(e)
+ dict_to_pass.update(self._init_from_xml(args[0]))
else:
dict_to_pass.update(
{k: _create_value(_get_rest_field(self._attr_to_rest_field, k), v) for k, v in args[0].items()}
@@ -662,8 +903,117 @@ def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
if v is not None
}
)
+ # Apply client default values for fields the caller didn't set so that
+ # defaults are part of `_data` and therefore included during serialization.
+ for rf in self._attr_to_rest_field.values():
+ if rf._default is _UNSET:
+ continue
+ if rf._rest_name in dict_to_pass:
+ continue
+ dict_to_pass[rf._rest_name] = _create_value(rf, rf._default)
super().__init__(dict_to_pass)
+ def _init_from_xml( # pylint: disable=too-many-branches, too-many-statements
+ self, element: ET.Element
+ ) -> dict[str, typing.Any]:
+ """Deserialize an XML element into a dict mapping rest field names to values.
+
+ :param ET.Element element: The XML element to deserialize from.
+ :returns: A dictionary of rest_name to deserialized value pairs.
+ :rtype: dict
+ """
+ result: dict[str, typing.Any] = {}
+ existed_attr_keys: list[str] = []
+
+ field_plan = getattr(self, "_xml_field_plan", None)
+ if field_plan:
+ for rest_name, xml_name, kind, deser, rf_type, is_optional, items_name in field_plan:
+ if kind == 0: # wrapped element (most common)
+ item = element.find(xml_name)
+ if item is not None:
+ existed_attr_keys.append(xml_name)
+ if deser:
+ result[rest_name] = deser(item)
+ else:
+ result[rest_name] = _deserialize(rf_type, item)
+ elif kind == 1: # attribute
+ attr_val = element.get(xml_name)
+ if attr_val is not None:
+ existed_attr_keys.append(xml_name)
+ if deser:
+ result[rest_name] = deser(attr_val)
+ else:
+ result[rest_name] = attr_val
+ elif kind == 2: # unwrapped array
+ items = element.findall(items_name) # pyright: ignore
+ if len(items) > 0:
+ existed_attr_keys.append(items_name)
+ if deser:
+ result[rest_name] = deser(items)
+ else:
+ result[rest_name] = _deserialize(rf_type, items)
+ elif not is_optional:
+ existed_attr_keys.append(items_name)
+ result[rest_name] = []
+ elif kind == 3: # text
+ if element.text is not None:
+ if deser:
+ result[rest_name] = deser(element.text)
+ else:
+ result[rest_name] = element.text
+ else:
+ model_meta = getattr(self, "_xml", {})
+ for rf in self._attr_to_rest_field.values():
+ prop_meta = getattr(rf, "_xml", {})
+ xml_name = prop_meta.get("name", rf._rest_name)
+ xml_ns = _resolve_xml_ns(prop_meta, model_meta)
+ if xml_ns:
+ xml_name = "{" + xml_ns + "}" + xml_name
+
+ # attribute
+ if prop_meta.get("attribute", False) and element.get(xml_name) is not None:
+ existed_attr_keys.append(xml_name)
+ result[rf._rest_name] = _deserialize(rf._type, element.get(xml_name))
+ continue
+
+ # unwrapped element is array
+ if prop_meta.get("unwrapped", False):
+ _items_name = prop_meta.get("itemsName")
+ if _items_name:
+ xml_name = _items_name
+ _items_ns = prop_meta.get("itemsNs")
+ if _items_ns is not None:
+ xml_ns = _items_ns
+ if xml_ns:
+ xml_name = "{" + xml_ns + "}" + xml_name
+ items = element.findall(xml_name) # pyright: ignore
+ if len(items) > 0:
+ existed_attr_keys.append(xml_name)
+ result[rf._rest_name] = _deserialize(rf._type, items)
+ elif not rf._is_optional:
+ existed_attr_keys.append(xml_name)
+ result[rf._rest_name] = []
+ continue
+
+ # text element is primitive type
+ if prop_meta.get("text", False):
+ if element.text is not None:
+ result[rf._rest_name] = _deserialize(rf._type, element.text)
+ continue
+
+ # wrapped element could be normal property or array
+ item = element.find(xml_name)
+ if item is not None:
+ existed_attr_keys.append(xml_name)
+ result[rf._rest_name] = _deserialize(rf._type, item)
+
+ # rest thing is additional properties
+ for e in element:
+ if e.tag not in existed_attr_keys:
+ result[e.tag] = _convert_element(e)
+
+ return result
+
def copy(self) -> "Model":
return Model(self.__dict__)
@@ -688,6 +1038,9 @@ def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> Self:
if not rf._rest_name_input:
rf._rest_name_input = attr
cls._attr_to_rest_field: dict[str, _RestField] = dict(attr_to_rest_field.items())
+ # Build XML field plan for fast _init_from_xml (only for XML models)
+ if getattr(cls, "_xml", None):
+ cls._xml_field_plan = _build_xml_field_plan(cls, attr_to_rest_field)
cls._calculated.add(f"{cls.__module__}.{cls.__qualname__}")
return super().__new__(cls)
@@ -716,7 +1069,7 @@ def _deserialize(cls, data, exist_discriminators):
model_meta = getattr(cls, "_xml", {})
prop_meta = getattr(discriminator, "_xml", {})
xml_name = prop_meta.get("name", discriminator._rest_name)
- xml_ns = prop_meta.get("ns", model_meta.get("ns", None))
+ xml_ns = _resolve_xml_ns(prop_meta, model_meta)
if xml_ns:
xml_name = "{" + xml_ns + "}" + xml_name
@@ -889,6 +1242,8 @@ def _get_deserialize_callable_from_annotation( # pylint: disable=too-many-retur
# is it optional?
try:
if any(a is _NONE_TYPE for a in annotation.__args__): # pyright: ignore
+ if rf:
+ rf._is_optional = True
if len(annotation.__args__) <= 2: # pyright: ignore
if_obj_deserializer = _get_deserialize_callable_from_annotation(
next(a for a in annotation.__args__ if a is not _NONE_TYPE), module, rf # pyright: ignore
@@ -981,16 +1336,20 @@ def _deserialize_with_callable(
return float(value.text) if value.text else None
if deserializer is bool:
return value.text == "true" if value.text else None
+ if deserializer and deserializer in _DESERIALIZE_MAPPING.values():
+ return deserializer(value.text) if value.text else None
+ if deserializer and deserializer in _DESERIALIZE_MAPPING_WITHFORMAT.values():
+ return deserializer(value.text) if value.text else None
if deserializer is None:
return value
if deserializer in [int, float, bool]:
return deserializer(value)
if isinstance(deserializer, CaseInsensitiveEnumMeta):
try:
- return deserializer(value)
+ return deserializer(value.text if isinstance(value, ET.Element) else value)
except ValueError:
# for unknown value, return raw value
- return value
+ return value.text if isinstance(value, ET.Element) else value
if isinstance(deserializer, type) and issubclass(deserializer, Model):
return deserializer._deserialize(value, [])
return typing.cast(typing.Callable[[typing.Any], typing.Any], deserializer)(value)
@@ -1043,6 +1402,7 @@ def _failsafe_deserialize_xml(
return None
+# pylint: disable=too-many-instance-attributes
class _RestField:
def __init__(
self,
@@ -1055,6 +1415,7 @@ def __init__(
format: typing.Optional[str] = None,
is_multipart_file_input: bool = False,
xml: typing.Optional[dict[str, typing.Any]] = None,
+ deserializer: typing.Optional[typing.Callable] = None,
):
self._type = type
self._rest_name_input = name
@@ -1062,10 +1423,12 @@ def __init__(
self._is_discriminator = is_discriminator
self._visibility = visibility
self._is_model = False
+ self._is_optional = False
self._default = default
self._format = format
self._is_multipart_file_input = is_multipart_file_input
self._xml = xml if xml is not None else {}
+ self._deserializer = deserializer
@property
def _class_type(self) -> typing.Any:
@@ -1085,7 +1448,10 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin
# by this point, type and rest_name will have a value bc we default
# them in __new__ of the Model class
# Use _data.get() directly to avoid triggering __getitem__ which clears the cache
- item = obj._data.get(self._rest_name)
+ item = obj._data.get(self._rest_name, _UNSET)
+ if item is _UNSET:
+ # Field not set by user; return the client default if one exists, otherwise None
+ return self._default if self._default is not _UNSET else None
if item is None:
return item
if self._is_model:
@@ -1098,7 +1464,11 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin
# Return the value from _data directly (it's been deserialized in place)
return obj._data.get(self._rest_name)
- deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self)
+ # Fast path: use _deserializer directly (avoids _serialize/_deserialize chain)
+ if self._deserializer:
+ deserialized = self._deserializer(item)
+ else:
+ deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self)
# For mutable types, store the deserialized value back in _data
# so mutations directly affect _data
@@ -1144,6 +1514,7 @@ def rest_field(
format: typing.Optional[str] = None,
is_multipart_file_input: bool = False,
xml: typing.Optional[dict[str, typing.Any]] = None,
+ deserializer: typing.Optional[typing.Callable] = None,
) -> typing.Any:
return _RestField(
name=name,
@@ -1153,6 +1524,7 @@ def rest_field(
format=format,
is_multipart_file_input=is_multipart_file_input,
xml=xml,
+ deserializer=deserializer,
)
@@ -1177,6 +1549,56 @@ def serialize_xml(model: Model, exclude_readonly: bool = False) -> str:
return ET.tostring(_get_element(model, exclude_readonly), encoding="unicode") # type: ignore
+def _get_xml_ns(meta: dict[str, typing.Any]) -> typing.Optional[str]:
+ """Return the XML namespace from a metadata dict, checking both 'ns' (old-style) and 'namespace' (DPG) keys.
+
+ :param dict meta: The metadata dictionary to extract namespace from.
+ :returns: The namespace string if 'ns' or 'namespace' key is present, None otherwise.
+ :rtype: str or None
+ """
+ ns = meta.get("ns")
+ if ns is None:
+ ns = meta.get("namespace")
+ return ns
+
+
+def _resolve_xml_ns(
+ prop_meta: dict[str, typing.Any], model_meta: typing.Optional[dict[str, typing.Any]] = None
+) -> typing.Optional[str]:
+ """Resolve XML namespace for a property, falling back to model namespace when appropriate.
+
+ Checks the property metadata first; if no namespace is found and the model does not declare
+ an explicit prefix, falls back to the model-level namespace.
+
+ :param dict prop_meta: The property metadata dictionary.
+ :param dict model_meta: The model metadata dictionary, used as fallback.
+ :returns: The resolved namespace string, or None.
+ :rtype: str or None
+ """
+ ns = _get_xml_ns(prop_meta)
+ if ns is None and model_meta is not None and not model_meta.get("prefix"):
+ ns = _get_xml_ns(model_meta)
+ return ns
+
+
+def _set_xml_attribute(element: ET.Element, name: str, value: typing.Any, prop_meta: dict[str, typing.Any]) -> None:
+ """Set an XML attribute on an element, handling namespace prefix registration.
+
+ :param ET.Element element: The element to set the attribute on.
+ :param str name: The default attribute name (wire name).
+ :param any value: The attribute value.
+ :param dict prop_meta: The property metadata dictionary.
+ """
+ xml_name = prop_meta.get("name", name)
+ _attr_ns = _get_xml_ns(prop_meta)
+ if _attr_ns:
+ _attr_prefix = prop_meta.get("prefix")
+ if _attr_prefix:
+ _safe_register_namespace(_attr_prefix, _attr_ns)
+ xml_name = "{" + _attr_ns + "}" + xml_name
+ element.set(xml_name, _get_primitive_type_value(value))
+
+
def _get_element(
o: typing.Any,
exclude_readonly: bool = False,
@@ -1188,10 +1610,16 @@ def _get_element(
# if prop is a model, then use the prop element directly, else generate a wrapper of model
if wrapped_element is None:
+ # When serializing as an array item (parent_meta is set), check if the parent has an
+ # explicit itemsName. This ensures correct element names for unwrapped arrays (where
+ # the element tag is the property/items name, not the model type name).
+ _items_name = parent_meta.get("itemsName") if parent_meta is not None else None
+ element_name = _items_name if _items_name else (model_meta.get("name") or o.__class__.__name__)
+ _model_ns = _get_xml_ns(model_meta)
wrapped_element = _create_xml_element(
- model_meta.get("name", o.__class__.__name__),
+ element_name,
model_meta.get("prefix"),
- model_meta.get("ns"),
+ _model_ns,
)
readonly_props = []
@@ -1213,7 +1641,9 @@ def _get_element(
# additional properties will not have rest field, use the wire name as xml name
prop_meta = {"name": k}
- # if no ns for prop, use model's
+ # Propagate model namespace to properties only for old-style "ns"-keyed models.
+ # DPG-generated models use the "namespace" key and explicitly declare namespace on
+ # each property that needs it, so propagation is intentionally skipped for them.
if prop_meta.get("ns") is None and model_meta.get("ns"):
prop_meta["ns"] = model_meta.get("ns")
prop_meta["prefix"] = model_meta.get("prefix")
@@ -1225,12 +1655,7 @@ def _get_element(
# text could only set on primitive type
wrapped_element.text = _get_primitive_type_value(v)
elif prop_meta.get("attribute", False):
- xml_name = prop_meta.get("name", k)
- if prop_meta.get("ns"):
- ET.register_namespace(prop_meta.get("prefix"), prop_meta.get("ns")) # pyright: ignore
- xml_name = "{" + prop_meta.get("ns") + "}" + xml_name # pyright: ignore
- # attribute should be primitive type
- wrapped_element.set(xml_name, _get_primitive_type_value(v))
+ _set_xml_attribute(wrapped_element, k, v, prop_meta)
else:
# other wrapped prop element
wrapped_element.append(_get_wrapped_element(v, exclude_readonly, prop_meta))
@@ -1239,6 +1664,7 @@ def _get_element(
return [_get_element(x, exclude_readonly, parent_meta) for x in o] # type: ignore
if isinstance(o, dict):
result = []
+ _dict_ns = _get_xml_ns(parent_meta) if parent_meta else None
for k, v in o.items():
result.append(
_get_wrapped_element(
@@ -1246,7 +1672,7 @@ def _get_element(
exclude_readonly,
{
"name": k,
- "ns": parent_meta.get("ns") if parent_meta else None,
+ "ns": _dict_ns,
"prefix": parent_meta.get("prefix") if parent_meta else None,
},
)
@@ -1255,13 +1681,16 @@ def _get_element(
# primitive case need to create element based on parent_meta
if parent_meta:
+ _items_ns = parent_meta.get("itemsNs")
+ if _items_ns is None:
+ _items_ns = _get_xml_ns(parent_meta)
return _get_wrapped_element(
o,
exclude_readonly,
{
"name": parent_meta.get("itemsName", parent_meta.get("name")),
"prefix": parent_meta.get("itemsPrefix", parent_meta.get("prefix")),
- "ns": parent_meta.get("itemsNs", parent_meta.get("ns")),
+ "ns": _items_ns,
},
)
@@ -1273,8 +1702,9 @@ def _get_wrapped_element(
exclude_readonly: bool,
meta: typing.Optional[dict[str, typing.Any]],
) -> ET.Element:
+ _meta_ns = _get_xml_ns(meta) if meta else None
wrapped_element = _create_xml_element(
- meta.get("name") if meta else None, meta.get("prefix") if meta else None, meta.get("ns") if meta else None
+ meta.get("name") if meta else None, meta.get("prefix") if meta else None, _meta_ns
)
if isinstance(v, (dict, list)):
wrapped_element.extend(_get_element(v, exclude_readonly, meta))
@@ -1295,11 +1725,29 @@ def _get_primitive_type_value(v) -> str:
return str(v)
+def _safe_register_namespace(prefix: str, ns: str) -> None:
+ """Register an XML namespace prefix, handling reserved prefix patterns.
+
+ Some prefixes (e.g. 'ns2') match Python's reserved 'ns\\d+' pattern used for
+ auto-generated prefixes, causing register_namespace to raise ValueError.
+ Falls back to directly registering in the internal namespace map.
+
+ :param str prefix: The namespace prefix to register.
+ :param str ns: The namespace URI.
+ """
+ try:
+ ET.register_namespace(prefix, ns)
+ except ValueError:
+ _ns_map = getattr(ET, "_namespace_map", None)
+ if _ns_map is not None:
+ _ns_map[ns] = prefix
+
+
def _create_xml_element(
tag: typing.Any, prefix: typing.Optional[str] = None, ns: typing.Optional[str] = None
) -> ET.Element:
if prefix and ns:
- ET.register_namespace(prefix, ns)
+ _safe_register_namespace(prefix, ns)
if ns:
return ET.Element("{" + ns + "}" + tag)
return ET.Element(tag)
@@ -1310,6 +1758,8 @@ def _deserialize_xml(
value: str,
) -> typing.Any:
element = ET.fromstring(value) # nosec
+ if _is_model(deserializer):
+ return deserializer._deserialize(element, [])
return _deserialize(deserializer, element)
diff --git a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_utils/serialization.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_utils/serialization.py
index 81ec1de5922b..ae08f9d89f74 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_utils/serialization.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_utils/serialization.py
@@ -39,11 +39,15 @@
import xml.etree.ElementTree as ET
import isodate # type: ignore
-from typing_extensions import Self
from azure.core.exceptions import DeserializationError, SerializationError
from azure.core.serialization import NULL as CoreNull
+if sys.version_info >= (3, 11):
+ from typing import Self
+else:
+ from typing_extensions import Self
+
_BOM = codecs.BOM_UTF8.decode(encoding="utf-8")
JSON = MutableMapping[str, Any]
@@ -476,7 +480,11 @@ def _decode_attribute_map_key(key):
class Serializer: # pylint: disable=too-many-public-methods
- """Request object model serializer."""
+ """Request object model serializer.
+
+ :param classes: Mapping of model names to model types, used to resolve models during serialization.
+ :type classes: typing.Optional[typing.Mapping[str, type]]
+ """
basic_types = {str: "str", int: "int", bool: "bool", float: "float"}
@@ -516,6 +524,10 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None:
"rfc-1123": Serializer.serialize_rfc,
"unix-time": Serializer.serialize_unix,
"duration": Serializer.serialize_duration,
+ "duration-seconds-int": Serializer.serialize_duration_seconds_int,
+ "duration-seconds-float": Serializer.serialize_duration_seconds_float,
+ "duration-milliseconds-int": Serializer.serialize_duration_milliseconds_int,
+ "duration-milliseconds-float": Serializer.serialize_duration_milliseconds_float,
"date": Serializer.serialize_date,
"time": Serializer.serialize_time,
"decimal": Serializer.serialize_decimal,
@@ -1105,6 +1117,61 @@ def serialize_duration(attr, **kwargs): # pylint: disable=unused-argument
attr = isodate.parse_duration(attr)
return isodate.duration_isoformat(attr)
+ @staticmethod
+ def _serialize_duration_numeric(attr, scale, as_int):
+ """Serialize a TimeDelta into a numeric value scaled to the wire unit.
+
+ :param TimeDelta attr: Object to be serialized.
+ :param int scale: Multiplier applied to total seconds (1 for seconds, 1000 for milliseconds).
+ :param bool as_int: Whether to truncate the result to an int.
+ :rtype: int or float
+ :return: serialized duration
+ """
+ if isinstance(attr, str):
+ attr = isodate.parse_duration(attr)
+ value = attr.total_seconds() * scale if isinstance(attr, datetime.timedelta) else attr
+ return int(value) if as_int else float(value)
+
+ @staticmethod
+ def serialize_duration_seconds_int(attr, **kwargs): # pylint: disable=unused-argument
+ """Serialize TimeDelta object into an integer number of seconds.
+
+ :param TimeDelta attr: Object to be serialized.
+ :rtype: int
+ :return: serialized duration
+ """
+ return Serializer._serialize_duration_numeric(attr, 1, True)
+
+ @staticmethod
+ def serialize_duration_seconds_float(attr, **kwargs): # pylint: disable=unused-argument
+ """Serialize TimeDelta object into a floating point number of seconds.
+
+ :param TimeDelta attr: Object to be serialized.
+ :rtype: float
+ :return: serialized duration
+ """
+ return Serializer._serialize_duration_numeric(attr, 1, False)
+
+ @staticmethod
+ def serialize_duration_milliseconds_int(attr, **kwargs): # pylint: disable=unused-argument
+ """Serialize TimeDelta object into an integer number of milliseconds.
+
+ :param TimeDelta attr: Object to be serialized.
+ :rtype: int
+ :return: serialized duration
+ """
+ return Serializer._serialize_duration_numeric(attr, 1000, True)
+
+ @staticmethod
+ def serialize_duration_milliseconds_float(attr, **kwargs): # pylint: disable=unused-argument
+ """Serialize TimeDelta object into a floating point number of milliseconds.
+
+ :param TimeDelta attr: Object to be serialized.
+ :rtype: float
+ :return: serialized duration
+ """
+ return Serializer._serialize_duration_numeric(attr, 1000, False)
+
@staticmethod
def serialize_rfc(attr, **kwargs): # pylint: disable=unused-argument
"""Serialize Datetime object into RFC-1123 formatted string.
@@ -1377,6 +1444,10 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None:
"rfc-1123": Deserializer.deserialize_rfc,
"unix-time": Deserializer.deserialize_unix,
"duration": Deserializer.deserialize_duration,
+ "duration-seconds-int": Deserializer.deserialize_duration_seconds,
+ "duration-seconds-float": Deserializer.deserialize_duration_seconds,
+ "duration-milliseconds-int": Deserializer.deserialize_duration_milliseconds,
+ "duration-milliseconds-float": Deserializer.deserialize_duration_milliseconds,
"date": Deserializer.deserialize_date,
"time": Deserializer.deserialize_time,
"decimal": Deserializer.deserialize_decimal,
@@ -1389,6 +1460,10 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None:
}
self.deserialize_expected_types = {
"duration": (isodate.Duration, datetime.timedelta),
+ "duration-seconds-int": (isodate.Duration, datetime.timedelta),
+ "duration-seconds-float": (isodate.Duration, datetime.timedelta),
+ "duration-milliseconds-int": (isodate.Duration, datetime.timedelta),
+ "duration-milliseconds-float": (isodate.Duration, datetime.timedelta),
"iso-8601": (datetime.datetime),
}
self.dependencies: dict[str, type] = dict(classes) if classes else {}
@@ -1401,7 +1476,7 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None:
# Otherwise, result are unexpected
self.additional_properties_detection = True
- def __call__(self, target_obj, response_data, content_type=None):
+ def __call__(self, target_obj, response_data, content_type=None): # pylint: disable=too-many-return-statements
"""Call the deserializer to process a REST response.
:param str target_obj: Target data type to deserialize to.
@@ -1411,6 +1486,27 @@ def __call__(self, target_obj, response_data, content_type=None):
:return: Deserialized object.
:rtype: object
"""
+ # Fast path for header deserialization: response_data is a plain str or None
+ # and target_obj is a simple scalar type. This avoids the expensive
+ # _unpack_content → _deserialize → _classify_target → deserialize_data chain.
+ if response_data is None:
+ return None
+ if target_obj == "str" and isinstance(response_data, str):
+ return response_data
+ if isinstance(response_data, str):
+ if target_obj == "int":
+ return int(response_data)
+ if target_obj == "bool":
+ if response_data in ("true", "1", "True"):
+ return True
+ if response_data in ("false", "0", "False"):
+ return False
+ return bool(response_data)
+ if target_obj == "rfc-1123":
+ return Deserializer.deserialize_rfc(response_data)
+ if target_obj == "bytearray":
+ return Deserializer.deserialize_bytearray(response_data)
+
data = self._unpack_content(response_data, content_type)
return self._deserialize(target_obj, data)
@@ -1929,6 +2025,48 @@ def deserialize_duration(attr):
raise DeserializationError(msg) from err
return duration
+ @staticmethod
+ def _deserialize_duration_numeric(attr, unit):
+ """Deserialize a numeric duration value into a TimeDelta object.
+
+ :param float attr: response value to be deserialized.
+ :param str unit: The wire unit, used as the ``timedelta`` keyword
+ (``"seconds"`` or ``"milliseconds"``).
+ :return: Deserialized duration
+ :rtype: TimeDelta
+ :raises DeserializationError: if value is invalid.
+ """
+ if isinstance(attr, ET.Element):
+ attr = attr.text
+ try:
+ duration = datetime.timedelta(**{unit: float(attr)}) # type: ignore
+ except (ValueError, OverflowError, TypeError) as err:
+ msg = "Cannot deserialize duration object."
+ raise DeserializationError(msg) from err
+ return duration
+
+ @staticmethod
+ def deserialize_duration_seconds(attr):
+ """Deserialize a numeric number of seconds into a TimeDelta object.
+
+ :param float attr: response value to be deserialized.
+ :return: Deserialized duration
+ :rtype: TimeDelta
+ :raises DeserializationError: if value is invalid.
+ """
+ return Deserializer._deserialize_duration_numeric(attr, "seconds")
+
+ @staticmethod
+ def deserialize_duration_milliseconds(attr):
+ """Deserialize a numeric number of milliseconds into a TimeDelta object.
+
+ :param float attr: response value to be deserialized.
+ :return: Deserialized duration
+ :rtype: TimeDelta
+ :raises DeserializationError: if value is invalid.
+ """
+ return Deserializer._deserialize_duration_numeric(attr, "milliseconds")
+
@staticmethod
def deserialize_date(attr):
"""Deserialize ISO-8601 formatted string into Date object.
diff --git a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_version.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_version.py
index e3c6eac445fd..18d3faabd3b4 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_version.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/_version.py
@@ -6,4 +6,4 @@
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
-VERSION = "19.0.0"
+VERSION = "20.0.0"
diff --git a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/_client.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/_client.py
index fc5c48180922..da10b20dc9fa 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/_client.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/_client.py
@@ -7,8 +7,8 @@
# --------------------------------------------------------------------------
from copy import deepcopy
+import sys
from typing import Any, Awaitable, Optional, TYPE_CHECKING, cast
-from typing_extensions import Self
from azure.core.pipeline import policies
from azure.core.rest import AsyncHttpResponse, HttpRequest
@@ -31,13 +31,18 @@
PrivateLinkResourceOperations,
)
+if sys.version_info >= (3, 11):
+ from typing import Self
+else:
+ from typing_extensions import Self # type: ignore
+
if TYPE_CHECKING:
from azure.core import AzureClouds
from azure.core.credentials_async import AsyncTokenCredential
-class BatchManagementClient: # pylint: disable=too-many-instance-attributes
- """The Batch Management Client.
+class BatchManagementClient: # pylint: disable=too-many-instance-attributes,docstring-keyword-should-match-keyword-only
+ """BatchManagementClient.
:ivar operations: Operations operations
:vartype operations: azure.mgmt.batch.aio.operations.Operations
@@ -68,7 +73,8 @@ class BatchManagementClient: # pylint: disable=too-many-instance-attributes
:keyword cloud_setting: The cloud setting for which to get the ARM endpoint. Default value is
None.
:paramtype cloud_setting: ~azure.core.AzureClouds
- :keyword api_version: The API version to use for this operation. Default value is "2025-06-01".
+ :keyword api_version: The API version to use for this operation. Known values are "2026-10-01"
+ and None. Default value is None. If not set, the operation's default API version will be used.
Note that overriding this default value may result in unsupported behavior.
:paramtype api_version: str
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no
diff --git a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/_configuration.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/_configuration.py
index 4ce9a6971612..2d01944a3cd5 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/_configuration.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/_configuration.py
@@ -1,3 +1,4 @@
+# pylint: disable=line-too-long,useless-suppression
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
@@ -18,7 +19,7 @@
from azure.core.credentials_async import AsyncTokenCredential
-class BatchManagementClientConfiguration: # pylint: disable=too-many-instance-attributes
+class BatchManagementClientConfiguration: # pylint: disable=too-many-instance-attributes,docstring-keyword-should-match-keyword-only
"""Configuration for BatchManagementClient.
Note that all parameters used to create this instance are saved as instance
@@ -33,7 +34,8 @@ class BatchManagementClientConfiguration: # pylint: disable=too-many-instance-a
:param cloud_setting: The cloud setting for which to get the ARM endpoint. Default value is
None.
:type cloud_setting: ~azure.core.AzureClouds
- :keyword api_version: The API version to use for this operation. Default value is "2025-06-01".
+ :keyword api_version: The API version to use for this operation. Known values are "2026-10-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
"""
@@ -46,7 +48,7 @@ def __init__(
cloud_setting: Optional["AzureClouds"] = None,
**kwargs: Any
) -> None:
- api_version: str = kwargs.pop("api_version", "2025-06-01")
+ api_version: str = kwargs.pop("api_version", "2026-10-01")
if credential is None:
raise ValueError("Parameter 'credential' must not be None.")
diff --git a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/_patch.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/_patch.py
index 87676c65a8f0..ea765788358a 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/_patch.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/_patch.py
@@ -8,7 +8,6 @@
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/batch/azure-mgmt-batch/azure/mgmt/batch/aio/operations/_operations.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/operations/_operations.py
index 95d68d85dd97..4bbe1887534f 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/operations/_operations.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/operations/_operations.py
@@ -34,7 +34,7 @@
from azure.mgmt.core.exceptions import ARMErrorFormat
from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling
-from ... import models as _models
+from ... import models as _models, types as _types
from ..._utils.model_base import SdkJSONEncoder, _deserialize, _failsafe_deserialize
from ..._utils.serialization import Deserializer, Serializer
from ...operations._operations import (
@@ -85,11 +85,10 @@
T = TypeVar("T")
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, dict[str, Any]], Any]]
-JSON = MutableMapping[str, Any]
List = list
-class Operations:
+class Operations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -153,7 +152,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -166,7 +168,10 @@ def prepare_request(next_link=None):
async def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.Operation], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.Operation],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, AsyncList(list_of_elem)
@@ -193,7 +198,7 @@ async def get_next(next_link=None):
return AsyncItemPaged(get_next, extract_data)
-class BatchAccountOperations:
+class BatchAccountOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -254,6 +259,7 @@ async def get(self, resource_group_name: str, account_name: str, **kwargs: Any)
}
_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
@@ -275,7 +281,7 @@ async def get(self, resource_group_name: str, account_name: str, **kwargs: Any)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.BatchAccount, response.json())
@@ -288,7 +294,7 @@ async def _create_initial(
self,
resource_group_name: str,
account_name: str,
- parameters: Union[_models.BatchAccountCreateParameters, JSON, IO[bytes]],
+ parameters: Union[_models.BatchAccountCreateParameters, _types.BatchAccountCreateParameters, IO[bytes]],
**kwargs: Any
) -> AsyncIterator[bytes]:
error_map: MutableMapping = {
@@ -327,6 +333,7 @@ async def _create_initial(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = True
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -351,7 +358,7 @@ async def _create_initial(
response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
if cls:
return cls(pipeline_response, deserialized, response_headers) # type: ignore
@@ -397,7 +404,7 @@ async def begin_create(
self,
resource_group_name: str,
account_name: str,
- parameters: JSON,
+ parameters: _types.BatchAccountCreateParameters,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -416,7 +423,7 @@ async def begin_create(
Required.
:type account_name: str
:param parameters: Additional parameters for account creation. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.BatchAccountCreateParameters
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -465,7 +472,7 @@ async def begin_create(
self,
resource_group_name: str,
account_name: str,
- parameters: Union[_models.BatchAccountCreateParameters, JSON, IO[bytes]],
+ parameters: Union[_models.BatchAccountCreateParameters, _types.BatchAccountCreateParameters, IO[bytes]],
**kwargs: Any
) -> AsyncLROPoller[_models.BatchAccount]:
"""Creates a new Batch account with the specified parameters. Existing accounts cannot be updated
@@ -481,9 +488,10 @@ async def begin_create(
`http://accountname.region.batch.azure.com/ `_.
Required.
:type account_name: str
- :param parameters: Additional parameters for account creation. Is one of the following types:
- BatchAccountCreateParameters, JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.BatchAccountCreateParameters or JSON or IO[bytes]
+ :param parameters: Additional parameters for account creation. Is either a
+ BatchAccountCreateParameters type or a IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.batch.models.BatchAccountCreateParameters or
+ ~azure.mgmt.batch.types.BatchAccountCreateParameters or IO[bytes]
:return: An instance of AsyncLROPoller that returns BatchAccount. The BatchAccount is
compatible with MutableMapping
:rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.batch.models.BatchAccount]
@@ -578,7 +586,7 @@ async def update(
self,
resource_group_name: str,
account_name: str,
- parameters: JSON,
+ parameters: _types.BatchAccountUpdateParameters,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -596,7 +604,7 @@ async def update(
Required.
:type account_name: str
:param parameters: Additional parameters for account update. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.BatchAccountUpdateParameters
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -642,7 +650,7 @@ async def update(
self,
resource_group_name: str,
account_name: str,
- parameters: Union[_models.BatchAccountUpdateParameters, JSON, IO[bytes]],
+ parameters: Union[_models.BatchAccountUpdateParameters, _types.BatchAccountUpdateParameters, IO[bytes]],
**kwargs: Any
) -> _models.BatchAccount:
"""Updates the properties of an existing Batch account.
@@ -657,9 +665,10 @@ async def update(
`http://accountname.region.batch.azure.com/ `_.
Required.
:type account_name: str
- :param parameters: Additional parameters for account update. Is one of the following types:
- BatchAccountUpdateParameters, JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.BatchAccountUpdateParameters or JSON or IO[bytes]
+ :param parameters: Additional parameters for account update. Is either a
+ BatchAccountUpdateParameters type or a IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.batch.models.BatchAccountUpdateParameters or
+ ~azure.mgmt.batch.types.BatchAccountUpdateParameters or IO[bytes]
:return: BatchAccount. The BatchAccount is compatible with MutableMapping
:rtype: ~azure.mgmt.batch.models.BatchAccount
:raises ~azure.core.exceptions.HttpResponseError:
@@ -700,6 +709,7 @@ async def update(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = kwargs.pop("stream", False)
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -721,7 +731,7 @@ async def update(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.BatchAccount, response.json())
@@ -757,6 +767,7 @@ async def _delete_initial(self, resource_group_name: str, account_name: str, **k
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = True
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -781,7 +792,7 @@ async def _delete_initial(self, resource_group_name: str, account_name: str, **k
response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
if cls:
return cls(pipeline_response, deserialized, response_headers) # type: ignore
@@ -902,7 +913,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -915,7 +929,10 @@ def prepare_request(next_link=None):
async def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.BatchAccount], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.BatchAccount],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, AsyncList(list_of_elem)
@@ -989,7 +1006,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -1002,7 +1022,10 @@ def prepare_request(next_link=None):
async def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.BatchAccount], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.BatchAccount],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, AsyncList(list_of_elem)
@@ -1133,7 +1156,7 @@ async def regenerate_key(
self,
resource_group_name: str,
account_name: str,
- parameters: JSON,
+ parameters: _types.BatchAccountRegenerateKeyParameters,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -1156,7 +1179,7 @@ async def regenerate_key(
Required.
:type account_name: str
:param parameters: The type of key to regenerate. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.BatchAccountRegenerateKeyParameters
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -1207,7 +1230,9 @@ async def regenerate_key(
self,
resource_group_name: str,
account_name: str,
- parameters: Union[_models.BatchAccountRegenerateKeyParameters, JSON, IO[bytes]],
+ parameters: Union[
+ _models.BatchAccountRegenerateKeyParameters, _types.BatchAccountRegenerateKeyParameters, IO[bytes]
+ ],
**kwargs: Any
) -> _models.BatchAccountKeys:
"""Regenerates the specified account key for the Batch account.
@@ -1227,10 +1252,10 @@ async def regenerate_key(
`http://accountname.region.batch.azure.com/ `_.
Required.
:type account_name: str
- :param parameters: The type of key to regenerate. Is one of the following types:
- BatchAccountRegenerateKeyParameters, JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.BatchAccountRegenerateKeyParameters or JSON or
- IO[bytes]
+ :param parameters: The type of key to regenerate. Is either a
+ BatchAccountRegenerateKeyParameters type or a IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.batch.models.BatchAccountRegenerateKeyParameters or
+ ~azure.mgmt.batch.types.BatchAccountRegenerateKeyParameters or IO[bytes]
:return: BatchAccountKeys. The BatchAccountKeys is compatible with MutableMapping
:rtype: ~azure.mgmt.batch.models.BatchAccountKeys
:raises ~azure.core.exceptions.HttpResponseError:
@@ -1271,6 +1296,7 @@ async def regenerate_key(
}
_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
@@ -1292,7 +1318,7 @@ async def regenerate_key(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.BatchAccountKeys, response.json())
@@ -1350,6 +1376,7 @@ async def get_keys(self, resource_group_name: str, account_name: str, **kwargs:
}
_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
@@ -1371,7 +1398,7 @@ async def get_keys(self, resource_group_name: str, account_name: str, **kwargs:
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.BatchAccountKeys, response.json())
@@ -1449,7 +1476,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -1462,7 +1492,10 @@ def prepare_request(next_link=None):
async def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.OutboundEnvironmentEndpoint], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.OutboundEnvironmentEndpoint],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, AsyncList(list_of_elem)
@@ -1537,6 +1570,7 @@ async def get_detector(
}
_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
@@ -1558,7 +1592,7 @@ async def get_detector(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.DetectorResponse, response.json())
@@ -1629,7 +1663,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -1642,7 +1679,10 @@ def prepare_request(next_link=None):
async def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.DetectorResponse], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.DetectorResponse],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, AsyncList(list_of_elem)
@@ -1669,7 +1709,7 @@ async def get_next(next_link=None):
return AsyncItemPaged(get_next, extract_data)
-class ApplicationPackageOperations:
+class ApplicationPackageOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -1739,6 +1779,7 @@ async def get(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = kwargs.pop("stream", False)
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -1760,7 +1801,7 @@ async def get(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.ApplicationPackage, response.json())
@@ -1818,7 +1859,7 @@ async def create(
account_name: str,
application_name: str,
version_name: str,
- parameters: Optional[JSON] = None,
+ parameters: Optional[_types.ApplicationPackage] = None,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -1844,7 +1885,7 @@ async def create(
:param version_name: The version of the application. Required.
:type version_name: str
:param parameters: The parameters for the request. Default value is None.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.ApplicationPackage
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -1902,7 +1943,7 @@ async def create(
account_name: str,
application_name: str,
version_name: str,
- parameters: Optional[Union[_models.ApplicationPackage, JSON, IO[bytes]]] = None,
+ parameters: Optional[Union[_models.ApplicationPackage, _types.ApplicationPackage, IO[bytes]]] = None,
**kwargs: Any
) -> _models.ApplicationPackage:
"""Creates an application package record. The record contains a storageUrl where the package
@@ -1925,9 +1966,10 @@ async def create(
:type application_name: str
:param version_name: The version of the application. Required.
:type version_name: str
- :param parameters: The parameters for the request. Is one of the following types:
- ApplicationPackage, JSON, IO[bytes] Default value is None.
- :type parameters: ~azure.mgmt.batch.models.ApplicationPackage or JSON or IO[bytes]
+ :param parameters: The parameters for the request. Is either a ApplicationPackage type or a
+ IO[bytes] type. Default value is None.
+ :type parameters: ~azure.mgmt.batch.models.ApplicationPackage or
+ ~azure.mgmt.batch.types.ApplicationPackage or IO[bytes]
:return: ApplicationPackage. The ApplicationPackage is compatible with MutableMapping
:rtype: ~azure.mgmt.batch.models.ApplicationPackage
:raises ~azure.core.exceptions.HttpResponseError:
@@ -1974,6 +2016,7 @@ async def create(
}
_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
@@ -1995,7 +2038,7 @@ async def create(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.ApplicationPackage, response.json())
@@ -2151,7 +2194,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -2164,7 +2210,10 @@ def prepare_request(next_link=None):
async def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.ApplicationPackage], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.ApplicationPackage],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, AsyncList(list_of_elem)
@@ -2238,7 +2287,7 @@ async def activate(
account_name: str,
application_name: str,
version_name: str,
- parameters: JSON,
+ parameters: _types.ActivateApplicationPackageParameters,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -2263,7 +2312,7 @@ async def activate(
:param version_name: The version of the application. Required.
:type version_name: str
:param parameters: The parameters for the request. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.ActivateApplicationPackageParameters
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -2320,7 +2369,9 @@ async def activate(
account_name: str,
application_name: str,
version_name: str,
- parameters: Union[_models.ActivateApplicationPackageParameters, JSON, IO[bytes]],
+ parameters: Union[
+ _models.ActivateApplicationPackageParameters, _types.ActivateApplicationPackageParameters, IO[bytes]
+ ],
**kwargs: Any
) -> _models.ApplicationPackage:
"""Activates the specified application package. This should be done after the
@@ -2342,10 +2393,10 @@ async def activate(
:type application_name: str
:param version_name: The version of the application. Required.
:type version_name: str
- :param parameters: The parameters for the request. Is one of the following types:
- ActivateApplicationPackageParameters, JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.ActivateApplicationPackageParameters or JSON or
- IO[bytes]
+ :param parameters: The parameters for the request. Is either a
+ ActivateApplicationPackageParameters type or a IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.batch.models.ActivateApplicationPackageParameters or
+ ~azure.mgmt.batch.types.ActivateApplicationPackageParameters or IO[bytes]
:return: ApplicationPackage. The ApplicationPackage is compatible with MutableMapping
:rtype: ~azure.mgmt.batch.models.ApplicationPackage
:raises ~azure.core.exceptions.HttpResponseError:
@@ -2388,6 +2439,7 @@ async def activate(
}
_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
@@ -2409,7 +2461,7 @@ async def activate(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.ApplicationPackage, response.json())
@@ -2419,7 +2471,7 @@ async def activate(
return deserialized # type: ignore
-class ApplicationOperations:
+class ApplicationOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -2486,6 +2538,7 @@ async def get(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = kwargs.pop("stream", False)
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -2507,7 +2560,7 @@ async def get(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Application, response.json())
@@ -2558,7 +2611,7 @@ async def create(
resource_group_name: str,
account_name: str,
application_name: str,
- parameters: Optional[JSON] = None,
+ parameters: Optional[_types.Application] = None,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -2579,7 +2632,7 @@ async def create(
Required.
:type application_name: str
:param parameters: The parameters for the request. Default value is None.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.Application
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -2630,7 +2683,7 @@ async def create(
resource_group_name: str,
account_name: str,
application_name: str,
- parameters: Optional[Union[_models.Application, JSON, IO[bytes]]] = None,
+ parameters: Optional[Union[_models.Application, _types.Application, IO[bytes]]] = None,
**kwargs: Any
) -> _models.Application:
"""Adds an application to the specified Batch account.
@@ -2648,9 +2701,10 @@ async def create(
:param application_name: The name of the application. This must be unique within the account.
Required.
:type application_name: str
- :param parameters: The parameters for the request. Is one of the following types: Application,
- JSON, IO[bytes] Default value is None.
- :type parameters: ~azure.mgmt.batch.models.Application or JSON or IO[bytes]
+ :param parameters: The parameters for the request. Is either a Application type or a IO[bytes]
+ type. Default value is None.
+ :type parameters: ~azure.mgmt.batch.models.Application or ~azure.mgmt.batch.types.Application
+ or IO[bytes]
:return: Application. The Application is compatible with MutableMapping
:rtype: ~azure.mgmt.batch.models.Application
:raises ~azure.core.exceptions.HttpResponseError:
@@ -2696,6 +2750,7 @@ async def create(
}
_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
@@ -2717,7 +2772,7 @@ async def create(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Application, response.json())
@@ -2768,7 +2823,7 @@ async def update(
resource_group_name: str,
account_name: str,
application_name: str,
- parameters: JSON,
+ parameters: _types.Application,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -2789,7 +2844,7 @@ async def update(
Required.
:type application_name: str
:param parameters: The parameters for the request. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.Application
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -2840,7 +2895,7 @@ async def update(
resource_group_name: str,
account_name: str,
application_name: str,
- parameters: Union[_models.Application, JSON, IO[bytes]],
+ parameters: Union[_models.Application, _types.Application, IO[bytes]],
**kwargs: Any
) -> _models.Application:
"""Updates settings for the specified application.
@@ -2858,9 +2913,10 @@ async def update(
:param application_name: The name of the application. This must be unique within the account.
Required.
:type application_name: str
- :param parameters: The parameters for the request. Is one of the following types: Application,
- JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.Application or JSON or IO[bytes]
+ :param parameters: The parameters for the request. Is either a Application type or a IO[bytes]
+ type. Required.
+ :type parameters: ~azure.mgmt.batch.models.Application or ~azure.mgmt.batch.types.Application
+ or IO[bytes]
:return: Application. The Application is compatible with MutableMapping
:rtype: ~azure.mgmt.batch.models.Application
:raises ~azure.core.exceptions.HttpResponseError:
@@ -2902,6 +2958,7 @@ async def update(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = kwargs.pop("stream", False)
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -2923,7 +2980,7 @@ async def update(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Application, response.json())
@@ -3064,7 +3121,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -3077,7 +3137,10 @@ def prepare_request(next_link=None):
async def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.Application], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.Application],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, AsyncList(list_of_elem)
@@ -3104,7 +3167,7 @@ async def get_next(next_link=None):
return AsyncItemPaged(get_next, extract_data)
-class PrivateLinkResourceOperations:
+class PrivateLinkResourceOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -3171,6 +3234,7 @@ async def get(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = kwargs.pop("stream", False)
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -3192,7 +3256,7 @@ async def get(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.PrivateLinkResource, response.json())
@@ -3267,7 +3331,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -3280,7 +3347,10 @@ def prepare_request(next_link=None):
async def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.PrivateLinkResource], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.PrivateLinkResource],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, AsyncList(list_of_elem)
@@ -3307,7 +3377,7 @@ async def get_next(next_link=None):
return AsyncItemPaged(get_next, extract_data)
-class PrivateEndpointConnectionOperations:
+class PrivateEndpointConnectionOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -3375,6 +3445,7 @@ async def get(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = kwargs.pop("stream", False)
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -3396,7 +3467,7 @@ async def get(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.PrivateEndpointConnection, response.json())
@@ -3410,7 +3481,7 @@ async def _update_initial(
resource_group_name: str,
account_name: str,
private_endpoint_connection_name: str,
- parameters: Union[_models.PrivateEndpointConnection, JSON, IO[bytes]],
+ parameters: Union[_models.PrivateEndpointConnection, _types.PrivateEndpointConnection, IO[bytes]],
*,
etag: Optional[str] = None,
match_condition: Optional[MatchConditions] = None,
@@ -3461,6 +3532,7 @@ async def _update_initial(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = True
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -3488,7 +3560,7 @@ async def _update_initial(
response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
if cls:
return cls(pipeline_response, deserialized, response_headers) # type: ignore
@@ -3546,7 +3618,7 @@ async def begin_update(
resource_group_name: str,
account_name: str,
private_endpoint_connection_name: str,
- parameters: JSON,
+ parameters: _types.PrivateEndpointConnection,
*,
content_type: str = "application/json",
etag: Optional[str] = None,
@@ -3570,7 +3642,7 @@ async def begin_update(
:type private_endpoint_connection_name: str
:param parameters: PrivateEndpointConnection properties that should be updated. Properties that
are supplied will be updated, any property not supplied will be unchanged. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.PrivateEndpointConnection
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -3636,7 +3708,7 @@ async def begin_update(
resource_group_name: str,
account_name: str,
private_endpoint_connection_name: str,
- parameters: Union[_models.PrivateEndpointConnection, JSON, IO[bytes]],
+ parameters: Union[_models.PrivateEndpointConnection, _types.PrivateEndpointConnection, IO[bytes]],
*,
etag: Optional[str] = None,
match_condition: Optional[MatchConditions] = None,
@@ -3658,9 +3730,10 @@ async def begin_update(
unique within the account. Required.
:type private_endpoint_connection_name: str
:param parameters: PrivateEndpointConnection properties that should be updated. Properties that
- are supplied will be updated, any property not supplied will be unchanged. Is one of the
- following types: PrivateEndpointConnection, JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.PrivateEndpointConnection or JSON or IO[bytes]
+ are supplied will be updated, any property not supplied will be unchanged. Is either a
+ PrivateEndpointConnection type or a IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.batch.models.PrivateEndpointConnection or
+ ~azure.mgmt.batch.types.PrivateEndpointConnection or IO[bytes]
:keyword etag: check if resource is changed. Set None to skip checking etag. Default value is
None.
:paramtype etag: str
@@ -3756,6 +3829,7 @@ async def _delete_initial(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = True
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -3783,7 +3857,7 @@ async def _delete_initial(
response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
if cls:
return cls(pipeline_response, deserialized, response_headers) # type: ignore
@@ -3925,7 +3999,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -3938,7 +4015,10 @@ def prepare_request(next_link=None):
async def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.PrivateEndpointConnection], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.PrivateEndpointConnection],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, AsyncList(list_of_elem)
@@ -3965,7 +4045,7 @@ async def get_next(next_link=None):
return AsyncItemPaged(get_next, extract_data)
-class PoolOperations:
+class PoolOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -4029,6 +4109,7 @@ async def get(self, resource_group_name: str, account_name: str, pool_name: str,
}
_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
@@ -4053,7 +4134,7 @@ async def get(self, resource_group_name: str, account_name: str, pool_name: str,
response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag"))
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Pool, response.json())
@@ -4110,7 +4191,7 @@ async def create(
resource_group_name: str,
account_name: str,
pool_name: str,
- parameters: JSON,
+ parameters: _types.Pool,
*,
content_type: str = "application/json",
etag: Optional[str] = None,
@@ -4132,7 +4213,7 @@ async def create(
:param pool_name: The pool name. This must be unique within the account. Required.
:type pool_name: str
:param parameters: Additional parameters for pool creation. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.Pool
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -4194,7 +4275,7 @@ async def create(
resource_group_name: str,
account_name: str,
pool_name: str,
- parameters: Union[_models.Pool, JSON, IO[bytes]],
+ parameters: Union[_models.Pool, _types.Pool, IO[bytes]],
*,
etag: Optional[str] = None,
match_condition: Optional[MatchConditions] = None,
@@ -4214,9 +4295,9 @@ async def create(
:type account_name: str
:param pool_name: The pool name. This must be unique within the account. Required.
:type pool_name: str
- :param parameters: Additional parameters for pool creation. Is one of the following types:
- Pool, JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.Pool or JSON or IO[bytes]
+ :param parameters: Additional parameters for pool creation. Is either a Pool type or a
+ IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.batch.models.Pool or ~azure.mgmt.batch.types.Pool or IO[bytes]
:keyword etag: check if resource is changed. Set None to skip checking etag. Default value is
None.
:paramtype etag: str
@@ -4271,6 +4352,7 @@ async def create(
}
_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
@@ -4295,7 +4377,7 @@ async def create(
response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag"))
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Pool, response.json())
@@ -4310,7 +4392,7 @@ async def update(
resource_group_name: str,
account_name: str,
pool_name: str,
- parameters: _models.Pool,
+ parameters: _models.PoolPatch,
*,
content_type: str = "application/json",
etag: Optional[str] = None,
@@ -4333,7 +4415,7 @@ async def update(
:type pool_name: str
:param parameters: Pool properties that should be updated. Properties that are supplied will be
updated, any property not supplied will be unchanged. Required.
- :type parameters: ~azure.mgmt.batch.models.Pool
+ :type parameters: ~azure.mgmt.batch.models.PoolPatch
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -4353,7 +4435,7 @@ async def update(
resource_group_name: str,
account_name: str,
pool_name: str,
- parameters: JSON,
+ parameters: _types.PoolPatch,
*,
content_type: str = "application/json",
etag: Optional[str] = None,
@@ -4376,7 +4458,7 @@ async def update(
:type pool_name: str
:param parameters: Pool properties that should be updated. Properties that are supplied will be
updated, any property not supplied will be unchanged. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.PoolPatch
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -4439,7 +4521,7 @@ async def update(
resource_group_name: str,
account_name: str,
pool_name: str,
- parameters: Union[_models.Pool, JSON, IO[bytes]],
+ parameters: Union[_models.PoolPatch, _types.PoolPatch, IO[bytes]],
*,
etag: Optional[str] = None,
match_condition: Optional[MatchConditions] = None,
@@ -4460,9 +4542,10 @@ async def update(
:param pool_name: The pool name. This must be unique within the account. Required.
:type pool_name: str
:param parameters: Pool properties that should be updated. Properties that are supplied will be
- updated, any property not supplied will be unchanged. Is one of the following types: Pool,
- JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.Pool or JSON or IO[bytes]
+ updated, any property not supplied will be unchanged. Is either a PoolPatch type or a IO[bytes]
+ type. Required.
+ :type parameters: ~azure.mgmt.batch.models.PoolPatch or ~azure.mgmt.batch.types.PoolPatch or
+ IO[bytes]
:keyword etag: check if resource is changed. Set None to skip checking etag. Default value is
None.
:paramtype etag: str
@@ -4517,6 +4600,7 @@ async def update(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = kwargs.pop("stream", False)
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -4541,7 +4625,7 @@ async def update(
response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag"))
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Pool, response.json())
@@ -4580,6 +4664,7 @@ async def _delete_initial(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = True
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -4604,7 +4689,7 @@ async def _delete_initial(
response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
if cls:
return cls(pipeline_response, deserialized, response_headers) # type: ignore
@@ -4771,7 +4856,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -4784,7 +4872,10 @@ def prepare_request(next_link=None):
async def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.Pool], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.Pool],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, AsyncList(list_of_elem)
@@ -4859,6 +4950,7 @@ async def disable_auto_scale(
}
_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
@@ -4883,7 +4975,7 @@ async def disable_auto_scale(
response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag"))
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Pool, response.json())
@@ -4948,6 +5040,7 @@ async def stop_resize(
}
_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
@@ -4972,7 +5065,7 @@ async def stop_resize(
response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag"))
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Pool, response.json())
@@ -4982,7 +5075,7 @@ async def stop_resize(
return deserialized # type: ignore
-class NetworkSecurityPerimeterOperations:
+class NetworkSecurityPerimeterOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -5054,6 +5147,7 @@ async def get_configuration(
}
_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
@@ -5075,7 +5169,7 @@ async def get_configuration(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.NetworkSecurityPerimeterConfiguration, response.json())
@@ -5147,7 +5241,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -5161,7 +5258,8 @@ def prepare_request(next_link=None):
async def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
list_of_elem = _deserialize(
- List[_models.NetworkSecurityPerimeterConfiguration], deserialized.get("value", [])
+ List[_models.NetworkSecurityPerimeterConfiguration],
+ deserialized.get("value", []),
)
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
@@ -5222,6 +5320,7 @@ async def _reconcile_configuration_initial(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = True
pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -5245,7 +5344,7 @@ async def _reconcile_configuration_initial(
response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
if cls:
return cls(pipeline_response, deserialized, response_headers) # type: ignore
@@ -5325,7 +5424,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-
return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore
-class LocationOperations:
+class LocationOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -5377,6 +5476,7 @@ async def get_quotas(self, location_name: str, **kwargs: Any) -> _models.BatchLo
}
_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
@@ -5398,7 +5498,7 @@ async def get_quotas(self, location_name: str, **kwargs: Any) -> _models.BatchLo
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.BatchLocationQuota, response.json())
@@ -5468,7 +5568,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -5481,7 +5584,10 @@ def prepare_request(next_link=None):
async def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.SupportedSku], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.SupportedSku],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, AsyncList(list_of_elem)
@@ -5533,14 +5639,19 @@ async def check_name_availability(
@overload
async def check_name_availability(
- self, location_name: str, parameters: JSON, *, content_type: str = "application/json", **kwargs: Any
+ self,
+ location_name: str,
+ parameters: _types.CheckNameAvailabilityParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
) -> _models.CheckNameAvailabilityResult:
"""Checks whether the Batch account name is available in the specified region.
:param location_name: The desired region for the name check. Required.
:type location_name: str
:param parameters: Properties needed to check the availability of a name. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.CheckNameAvailabilityParameters
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -5573,16 +5684,17 @@ async def check_name_availability(
async def check_name_availability(
self,
location_name: str,
- parameters: Union[_models.CheckNameAvailabilityParameters, JSON, IO[bytes]],
+ parameters: Union[_models.CheckNameAvailabilityParameters, _types.CheckNameAvailabilityParameters, IO[bytes]],
**kwargs: Any
) -> _models.CheckNameAvailabilityResult:
"""Checks whether the Batch account name is available in the specified region.
:param location_name: The desired region for the name check. Required.
:type location_name: str
- :param parameters: Properties needed to check the availability of a name. Is one of the
- following types: CheckNameAvailabilityParameters, JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.CheckNameAvailabilityParameters or JSON or IO[bytes]
+ :param parameters: Properties needed to check the availability of a name. Is either a
+ CheckNameAvailabilityParameters type or a IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.batch.models.CheckNameAvailabilityParameters or
+ ~azure.mgmt.batch.types.CheckNameAvailabilityParameters or IO[bytes]
:return: CheckNameAvailabilityResult. The CheckNameAvailabilityResult is compatible with
MutableMapping
:rtype: ~azure.mgmt.batch.models.CheckNameAvailabilityResult
@@ -5623,6 +5735,7 @@ async def check_name_availability(
}
_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
@@ -5644,7 +5757,7 @@ async def check_name_availability(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.CheckNameAvailabilityResult, response.json())
diff --git a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/operations/_patch.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/operations/_patch.py
index 87676c65a8f0..ea765788358a 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/operations/_patch.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/aio/operations/_patch.py
@@ -8,7 +8,6 @@
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/batch/azure-mgmt-batch/azure/mgmt/batch/models/__init__.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/models/__init__.py
index a083d0af6ed1..a83451fa1f34 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/models/__init__.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/models/__init__.py
@@ -32,7 +32,6 @@
AutomaticOSUpgradePolicy,
AzureBlobFileSystemConfiguration,
AzureFileShareConfiguration,
- AzureResource,
BatchAccount,
BatchAccountCreateParameters,
BatchAccountCreateProperties,
@@ -55,6 +54,7 @@
ContainerRegistry,
DataDisk,
DeploymentConfiguration,
+ DeploymentConfigurationPatch,
DetectorResponse,
DetectorResponseProperties,
DiffDiskSettings,
@@ -70,6 +70,7 @@
ErrorDetail,
ErrorResponse,
FixedScaleSettings,
+ HardwareProfile,
HostEndpointSettings,
IPRule,
IPTag,
@@ -79,6 +80,8 @@
KeyVaultReference,
LinuxUserConfiguration,
ManagedDisk,
+ MaxInstancePercentPerZonePolicy,
+ MaxInstancePercentPerZonePolicyPatch,
MetadataItem,
MountConfiguration,
NFSMountConfiguration,
@@ -94,8 +97,12 @@
Operation,
OperationDisplay,
OutboundEnvironmentEndpoint,
+ Placement,
+ PlacementPatch,
Pool,
PoolEndpointConfiguration,
+ PoolPatch,
+ PoolPatchProperties,
PoolProperties,
PrivateEndpoint,
PrivateEndpointConnection,
@@ -108,6 +115,8 @@
ProxyAgentSettings,
ProxyResource,
PublicIPAddressConfiguration,
+ ResiliencyPolicy,
+ ResiliencyPolicyPatch,
ResizeError,
ResizeOperationStatus,
Resource,
@@ -123,6 +132,7 @@
SystemData,
TaskContainerSettings,
TaskSchedulingPolicy,
+ TrackedResource,
UefiSettings,
UpgradePolicy,
UserAccount,
@@ -131,9 +141,15 @@
VMDiskSecurityProfile,
VMExtension,
VirtualMachineConfiguration,
+ VirtualMachineConfigurationPatch,
VirtualMachineFamilyCoreQuota,
+ VirtualMachineSkuProfile,
+ VirtualMachineSkuProfileVmSize,
+ VmSizeProperties,
WindowsConfiguration,
WindowsUserConfiguration,
+ ZoneAllocationPolicy,
+ ZoneAllocationPolicyPatch,
)
from ._enums import ( # type: ignore
@@ -177,6 +193,7 @@
PrivateLinkServiceConnectionStatus,
ProvisioningState,
PublicNetworkAccessType,
+ RequestedComputeNodeDeallocationOption,
ResourceAssociationAccessMode,
ResourceIdentityType,
ResourceType,
@@ -185,6 +202,8 @@
Severity,
StorageAccountType,
UpgradeMode,
+ VirtualMachineSkuAllocationStrategy,
+ ZonePlacementPolicyType,
)
from ._patch import __all__ as _patch_all
from ._patch import *
@@ -209,7 +228,6 @@
"AutomaticOSUpgradePolicy",
"AzureBlobFileSystemConfiguration",
"AzureFileShareConfiguration",
- "AzureResource",
"BatchAccount",
"BatchAccountCreateParameters",
"BatchAccountCreateProperties",
@@ -232,6 +250,7 @@
"ContainerRegistry",
"DataDisk",
"DeploymentConfiguration",
+ "DeploymentConfigurationPatch",
"DetectorResponse",
"DetectorResponseProperties",
"DiffDiskSettings",
@@ -247,6 +266,7 @@
"ErrorDetail",
"ErrorResponse",
"FixedScaleSettings",
+ "HardwareProfile",
"HostEndpointSettings",
"IPRule",
"IPTag",
@@ -256,6 +276,8 @@
"KeyVaultReference",
"LinuxUserConfiguration",
"ManagedDisk",
+ "MaxInstancePercentPerZonePolicy",
+ "MaxInstancePercentPerZonePolicyPatch",
"MetadataItem",
"MountConfiguration",
"NFSMountConfiguration",
@@ -271,8 +293,12 @@
"Operation",
"OperationDisplay",
"OutboundEnvironmentEndpoint",
+ "Placement",
+ "PlacementPatch",
"Pool",
"PoolEndpointConfiguration",
+ "PoolPatch",
+ "PoolPatchProperties",
"PoolProperties",
"PrivateEndpoint",
"PrivateEndpointConnection",
@@ -285,6 +311,8 @@
"ProxyAgentSettings",
"ProxyResource",
"PublicIPAddressConfiguration",
+ "ResiliencyPolicy",
+ "ResiliencyPolicyPatch",
"ResizeError",
"ResizeOperationStatus",
"Resource",
@@ -300,6 +328,7 @@
"SystemData",
"TaskContainerSettings",
"TaskSchedulingPolicy",
+ "TrackedResource",
"UefiSettings",
"UpgradePolicy",
"UserAccount",
@@ -308,9 +337,15 @@
"VMDiskSecurityProfile",
"VMExtension",
"VirtualMachineConfiguration",
+ "VirtualMachineConfigurationPatch",
"VirtualMachineFamilyCoreQuota",
+ "VirtualMachineSkuProfile",
+ "VirtualMachineSkuProfileVmSize",
+ "VmSizeProperties",
"WindowsConfiguration",
"WindowsUserConfiguration",
+ "ZoneAllocationPolicy",
+ "ZoneAllocationPolicyPatch",
"AccessRuleDirection",
"AccountKeyType",
"AllocationState",
@@ -351,6 +386,7 @@
"PrivateLinkServiceConnectionStatus",
"ProvisioningState",
"PublicNetworkAccessType",
+ "RequestedComputeNodeDeallocationOption",
"ResourceAssociationAccessMode",
"ResourceIdentityType",
"ResourceType",
@@ -359,6 +395,8 @@
"Severity",
"StorageAccountType",
"UpgradeMode",
+ "VirtualMachineSkuAllocationStrategy",
+ "ZonePlacementPolicyType",
]
__all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore
_patch_sdk()
diff --git a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/models/_enums.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/models/_enums.py
index 876f2768cfd2..dd498d868488 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/models/_enums.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/models/_enums.py
@@ -49,8 +49,6 @@ class AuthenticationMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
"""The authentication mode using shared keys."""
AAD = "AAD"
"""The authentication mode using Microsoft Entra ID."""
- TASK_AUTHENTICATION_TOKEN = "TaskAuthenticationToken"
- """The authentication mode using task authentication tokens."""
class AutoStorageAuthenticationMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
@@ -352,19 +350,19 @@ class NetworkSecurityPerimeterConfigurationProvisioningState( # pylint: disable
"""
SUCCEEDED = "Succeeded"
- """SUCCEEDED."""
+ """The configuration was provisioned successfully."""
CREATING = "Creating"
- """CREATING."""
+ """The configuration is being created."""
UPDATING = "Updating"
- """UPDATING."""
+ """The configuration is being updated."""
DELETING = "Deleting"
- """DELETING."""
+ """The configuration is being deleted."""
ACCEPTED = "Accepted"
- """ACCEPTED."""
+ """The configuration request was accepted and provisioning has not started yet."""
FAILED = "Failed"
- """FAILED."""
+ """The configuration failed to provision."""
CANCELED = "Canceled"
- """CANCELED."""
+ """The configuration provisioning was canceled."""
class NodePlacementPolicyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
@@ -477,6 +475,23 @@ class PublicNetworkAccessType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
"""Secures connectivity to Azure Batch through NSP configuration."""
+class RequestedComputeNodeDeallocationOption(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ """Determines what to do with a node and its running task(s) after it has been selected for
+ deallocation. This is the set of values that can be requested; ``RetainedData`` is no longer
+ accepted as of the 2026-10-01 API version.
+ """
+
+ REQUEUE = "Requeue"
+ """Terminate running task processes and requeue the tasks. The tasks will run again when a node is
+ available. Remove nodes as soon as tasks have been terminated."""
+ TERMINATE = "Terminate"
+ """Terminate running tasks. The tasks will be completed with failureInfo indicating that they were
+ terminated, and will not run again. Remove nodes as soon as tasks have been terminated."""
+ TASK_COMPLETION = "TaskCompletion"
+ """Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes
+ when all tasks have completed."""
+
+
class ResourceAssociationAccessMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
"""Access mode of the resource association."""
@@ -544,9 +559,9 @@ class Severity(str, Enum, metaclass=CaseInsensitiveEnumMeta):
"""Severity of the issue."""
WARNING = "Warning"
- """WARNING."""
+ """The issue is a warning and does not prevent the configuration from being applied."""
ERROR = "Error"
- """ERROR."""
+ """The issue is an error and prevents the configuration from being applied."""
class StorageAccountType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
@@ -578,3 +593,25 @@ class UpgradeMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
"""The existing instances in a scale set are brought down in batches to be upgraded. Once the
upgraded batch is complete, the instances will begin taking traffic again and the next batch
will begin. This continues until all instances brought up-to-date."""
+
+
+class VirtualMachineSkuAllocationStrategy(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ """Specifies the allocation strategy that the Fungible Compute Platform uses to select VM sizes
+ from the vmSkuProfile when allocating nodes for an Instance Mix pool.
+ """
+
+ LOWEST_PRICE = "LowestPrice"
+ """Select the cheapest available SKU in the region. This is the default strategy."""
+ CAPACITY_OPTIMIZED = "CapacityOptimized"
+ """Select the SKU with the most regional physical capacity."""
+ PRIORITIZED = "Prioritized"
+ """Follow the customer-defined ranking via the 0-based rank, falling back to the next rank when a
+ preferred SKU is unavailable."""
+
+
+class ZonePlacementPolicyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+ """The zone placement policy for compute nodes in a pool."""
+
+ AUTO = "Auto"
+ """The Virtual Machine Scale Set automatically selects availability zones and balances instances
+ across them."""
diff --git a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/models/_models.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/models/_models.py
index d31c21504f1d..5f062eba4f41 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/models/_models.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/models/_models.py
@@ -17,12 +17,12 @@
from .. import models as _models
-class AccessRule(_Model):
+class AccessRule(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Access rule in a network security perimeter configuration profile.
:ivar name: Name of the access rule.
:vartype name: str
- :ivar properties:
+ :ivar properties: Properties of the access rule.
:vartype properties: ~azure.mgmt.batch.models.AccessRuleProperties
"""
@@ -31,6 +31,7 @@ class AccessRule(_Model):
properties: Optional["_models.AccessRuleProperties"] = rest_field(
visibility=["read", "create", "update", "delete", "query"]
)
+ """Properties of the access rule."""
@overload
def __init__(
@@ -51,10 +52,10 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class AccessRuleProperties(_Model):
+class AccessRuleProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Properties of Access Rule.
- :ivar direction: Known values are: "Inbound" and "Outbound".
+ :ivar direction: Direction of the access rule. Known values are: "Inbound" and "Outbound".
:vartype direction: str or ~azure.mgmt.batch.models.AccessRuleDirection
:ivar address_prefixes: Address prefixes in the CIDR format for inbound rules.
:vartype address_prefixes: list[str]
@@ -73,7 +74,7 @@ class AccessRuleProperties(_Model):
direction: Optional[Union[str, "_models.AccessRuleDirection"]] = rest_field(
visibility=["read", "create", "update", "delete", "query"]
)
- """Known values are: \"Inbound\" and \"Outbound\"."""
+ """Direction of the access rule. Known values are: \"Inbound\" and \"Outbound\"."""
address_prefixes: Optional[list[str]] = rest_field(
name="addressPrefixes", visibility=["read", "create", "update", "delete", "query"]
)
@@ -123,7 +124,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class AccessRulePropertiesSubscription(_Model):
+class AccessRulePropertiesSubscription(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""AccessRulePropertiesSubscription.
:ivar id: The fully qualified Azure resource ID of the subscription e.g.
@@ -153,7 +154,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class ActivateApplicationPackageParameters(_Model):
+class ActivateApplicationPackageParameters(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Parameters for an activating an application package.
:ivar format: The format of the application package binary file. Required.
@@ -226,7 +227,7 @@ class ProxyResource(Resource):
"""
-class Application(ProxyResource):
+class Application(ProxyResource): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Contains information about an application in a Batch account.
:ivar id: Fully qualified resource ID for the resource. Ex -
@@ -296,7 +297,7 @@ def __setattr__(self, key: str, value: Any) -> None:
super().__setattr__(key, value)
-class ApplicationPackage(ProxyResource):
+class ApplicationPackage(ProxyResource): # pylint: disable=docstring-keyword-should-match-keyword-only
"""An application package which represents a particular version of an application.
:ivar id: Fully qualified resource ID for the resource. Ex -
@@ -374,9 +375,14 @@ class ApplicationPackageProperties(_Model):
:vartype state: str or ~azure.mgmt.batch.models.PackageState
:ivar format: The format of the application package, if the package is active.
:vartype format: str
- :ivar storage_url: The URL for the application package in Azure Storage.
+ :ivar storage_url: The URL for the application package in Azure Storage. This property is only
+ returned for the PUT application package (create or update) operation. For the GET application
+ package and POST activate application package operations, this property is not populated.
:vartype storage_url: str
- :ivar storage_url_expiry: The UTC time at which the Azure Storage URL will expire.
+ :ivar storage_url_expiry: The UTC time at which the Azure Storage URL will expire. This
+ property is only returned for the PUT application package (create or update) operation. For the
+ GET application package and POST activate application package operations, this property is not
+ populated.
:vartype storage_url_expiry: ~datetime.datetime
:ivar last_activation_time: The time at which the package was last activated, if the package is
active.
@@ -388,18 +394,22 @@ class ApplicationPackageProperties(_Model):
format: Optional[str] = rest_field(visibility=["read"])
"""The format of the application package, if the package is active."""
storage_url: Optional[str] = rest_field(name="storageUrl", visibility=["read"])
- """The URL for the application package in Azure Storage."""
+ """The URL for the application package in Azure Storage. This property is only returned for the
+ PUT application package (create or update) operation. For the GET application package and POST
+ activate application package operations, this property is not populated."""
storage_url_expiry: Optional[datetime.datetime] = rest_field(
name="storageUrlExpiry", visibility=["read"], format="rfc3339"
)
- """The UTC time at which the Azure Storage URL will expire."""
+ """The UTC time at which the Azure Storage URL will expire. This property is only returned for the
+ PUT application package (create or update) operation. For the GET application package and POST
+ activate application package operations, this property is not populated."""
last_activation_time: Optional[datetime.datetime] = rest_field(
name="lastActivationTime", visibility=["read"], format="rfc3339"
)
"""The time at which the package was last activated, if the package is active."""
-class ApplicationPackageReference(_Model):
+class ApplicationPackageReference(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Link to an application package inside the batch account.
:ivar id: The ID of the application package to install. This must be inside the same Batch
@@ -437,7 +447,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class ApplicationProperties(_Model):
+class ApplicationProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The properties associated with the Application.
:ivar display_name: The display name for the application.
@@ -485,7 +495,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class AutomaticOSUpgradePolicy(_Model):
+class AutomaticOSUpgradePolicy(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The configuration parameters used for performing automatic OS upgrade.
:ivar disable_automatic_rollback: Whether OS image rollback feature should be disabled.
@@ -548,7 +558,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class AutoScaleRun(_Model):
+class AutoScaleRun(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The results and errors from an execution of a pool autoscale formula.
:ivar evaluation_time: The time at which the autoscale formula was last evaluated. Required.
@@ -593,7 +603,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class AutoScaleRunError(_Model):
+class AutoScaleRunError(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""An error that occurred when autoscaling a pool.
:ivar code: An identifier for the error. Codes are invariant and are intended to be consumed
@@ -637,7 +647,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class AutoScaleSettings(_Model):
+class AutoScaleSettings(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""AutoScale settings for the pool.
:ivar formula: A formula for the desired number of compute nodes in the pool. Required.
@@ -674,7 +684,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class AutoStorageBaseProperties(_Model):
+class AutoStorageBaseProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The properties related to the auto-storage account.
:ivar storage_account_id: The resource ID of the storage account to be used for auto-storage
@@ -723,7 +733,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class AutoStorageProperties(AutoStorageBaseProperties):
+class AutoStorageProperties(AutoStorageBaseProperties): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Contains information about the auto-storage account associated with a Batch account.
:ivar storage_account_id: The resource ID of the storage account to be used for auto-storage
@@ -766,7 +776,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class AutoUserSpecification(_Model):
+class AutoUserSpecification(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Specifies the parameters for the auto user that runs a task on the Batch service.
:ivar scope: The scope for the auto user. Known values are: "Task" and "Pool".
@@ -804,7 +814,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class AzureBlobFileSystemConfiguration(_Model):
+class AzureBlobFileSystemConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Information used to connect to an Azure Storage Container using Blobfuse.
:ivar account_name: The Azure Storage Account name. Required.
@@ -872,7 +882,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class AzureFileShareConfiguration(_Model):
+class AzureFileShareConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Information used to connect to an Azure Fileshare.
:ivar account_name: The Azure Storage account name. Required.
@@ -925,7 +935,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class AzureResource(Resource):
+class TrackedResource(Resource): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Tracked Resource.
:ivar id: Fully qualified resource ID for the resource. Ex -
@@ -969,7 +979,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class BatchAccount(AzureResource):
+class BatchAccount(TrackedResource): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Contains information about an Azure Batch account.
:ivar id: Fully qualified resource ID for the resource. Ex -
@@ -1061,7 +1071,7 @@ def __setattr__(self, key: str, value: Any) -> None:
super().__setattr__(key, value)
-class BatchAccountCreateParameters(_Model):
+class BatchAccountCreateParameters(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Parameters supplied to the Create operation.
:ivar location: The region in which to create the account. Required.
@@ -1136,7 +1146,7 @@ def __setattr__(self, key: str, value: Any) -> None:
super().__setattr__(key, value)
-class BatchAccountCreateProperties(_Model):
+class BatchAccountCreateProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The properties of a Batch account.
:ivar auto_storage: The properties related to the auto-storage account.
@@ -1217,7 +1227,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class BatchAccountIdentity(_Model):
+class BatchAccountIdentity(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The identity of the Batch account, if configured. This is used when the user specifies
'Microsoft.KeyVault' as their Batch account encryption configuration or when
``ManagedIdentity`` is selected as the auto-storage authentication mode.
@@ -1289,7 +1299,7 @@ class BatchAccountKeys(_Model):
"""The secondary key associated with the account."""
-class BatchAccountProperties(_Model):
+class BatchAccountProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Account specific properties.
:ivar account_endpoint: The account endpoint used to interact with the Batch service.
@@ -1424,7 +1434,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class BatchAccountRegenerateKeyParameters(_Model):
+class BatchAccountRegenerateKeyParameters(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Parameters supplied to the RegenerateKey operation.
:ivar key_name: The type of account key to regenerate. Required. Known values are: "Primary"
@@ -1456,7 +1466,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class BatchAccountUpdateParameters(_Model):
+class BatchAccountUpdateParameters(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Parameters for updating an Azure Batch account.
:ivar tags: The user-specified tags associated with the account.
@@ -1524,7 +1534,7 @@ def __setattr__(self, key: str, value: Any) -> None:
super().__setattr__(key, value)
-class BatchAccountUpdateProperties(_Model):
+class BatchAccountUpdateProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The properties of a Batch account.
:ivar auto_storage: The properties related to the auto-storage account.
@@ -1601,7 +1611,7 @@ class BatchLocationQuota(_Model):
region."""
-class BatchPoolIdentity(_Model):
+class BatchPoolIdentity(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The identity of the Batch pool, if configured. If the pool identity is updated during update an
existing pool, only the new vms which are created after the pool shrinks to 0 will have the
updated identities.
@@ -1642,7 +1652,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class CheckNameAvailabilityParameters(_Model):
+class CheckNameAvailabilityParameters(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Parameters for a check name availability request.
:ivar name: The name to check for availability. Required.
@@ -1699,7 +1709,7 @@ class CheckNameAvailabilityResult(_Model):
"""Gets an error message explaining the Reason value in more detail."""
-class CIFSMountConfiguration(_Model):
+class CIFSMountConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Information used to connect to a CIFS file system.
:ivar user_name: The user to use for authentication against the CIFS file system. Required.
@@ -1752,7 +1762,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class CloudError(_Model):
+class CloudError(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""An error response from the Batch service.
:ivar error: The body of the error response.
@@ -1780,7 +1790,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class CloudErrorBody(_Model):
+class CloudErrorBody(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""An error response from the Batch service.
:ivar code: An identifier for the error. Codes are invariant and are intended to be consumed
@@ -1829,7 +1839,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class ComputeNodeIdentityReference(_Model):
+class ComputeNodeIdentityReference(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The reference to a user assigned identity associated with the Batch pool which a compute node
will use.
@@ -1860,7 +1870,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class ContainerConfiguration(_Model):
+class ContainerConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The configuration for container-enabled pools.
:ivar type: The container technology to be used. Required. Known values are: "DockerCompatible"
@@ -1904,7 +1914,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class ContainerHostBatchBindMountEntry(_Model):
+class ContainerHostBatchBindMountEntry(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The entry of path and mount mode you want to mount into task container.
:ivar source: The paths which will be mounted to container task's container. Known values are:
@@ -1944,7 +1954,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class ContainerRegistry(_Model):
+class ContainerRegistry(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""A private container registry.
:ivar user_name: The user name to log into the registry server.
@@ -1993,7 +2003,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class DataDisk(_Model):
+class DataDisk(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Settings which will be used by the data disks associated to Compute Nodes in the Pool. When
using attached data disks, you need to mount and format the disks from within a VM to use them.
@@ -2043,7 +2053,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class DeploymentConfiguration(_Model):
+class DeploymentConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Deployment configuration properties.
:ivar virtual_machine_configuration: The virtual machine configuration for the pool.
@@ -2073,7 +2083,38 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class DetectorResponse(ProxyResource):
+class DeploymentConfigurationPatch(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """Deployment settings with partial updates for the new zone policies.
+
+ :ivar virtual_machine_configuration: The virtual machine configuration for the pool.
+ :vartype virtual_machine_configuration:
+ ~azure.mgmt.batch.models.VirtualMachineConfigurationPatch
+ """
+
+ virtual_machine_configuration: Optional["_models.VirtualMachineConfigurationPatch"] = rest_field(
+ name="virtualMachineConfiguration", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The virtual machine configuration for the pool."""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ virtual_machine_configuration: Optional["_models.VirtualMachineConfigurationPatch"] = 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 DetectorResponse(ProxyResource): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Contains the information for a detector.
:ivar id: Fully qualified resource ID for the resource. Ex -
@@ -2143,7 +2184,7 @@ def __setattr__(self, key: str, value: Any) -> None:
super().__setattr__(key, value)
-class DetectorResponseProperties(_Model):
+class DetectorResponseProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Detector response properties.
:ivar value: A base64 encoded string that represents the content of a detector.
@@ -2171,7 +2212,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class DiffDiskSettings(_Model):
+class DiffDiskSettings(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Specifies the ephemeral Disk Settings for the operating system disk used by the virtual
machine.
@@ -2204,7 +2245,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class DiskCustomerManagedKey(_Model):
+class DiskCustomerManagedKey(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The Customer Managed Key reference to encrypt the Disk.
:ivar key_url: Fully versioned Key Url pointing to a key in KeyVault. Version segment of the
@@ -2252,7 +2293,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class DiskEncryptionConfiguration(_Model):
+class DiskEncryptionConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The disk encryption configuration applied on compute nodes in the pool. Disk encryption
configuration is not supported on Linux pool created with Virtual Machine Image or Azure
Compute Gallery Image.
@@ -2291,7 +2332,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class DiskEncryptionSetParameters(_Model):
+class DiskEncryptionSetParameters(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The ARM resource id of the disk encryption set.
:ivar id: The resource id of the disk encryption set. Required.
@@ -2319,7 +2360,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class EncryptionProperties(_Model):
+class EncryptionProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Configures how customer data is encrypted inside the Batch account. By default, accounts are
encrypted using a Microsoft managed key. For additional control, a customer-managed key can be
used instead.
@@ -2359,7 +2400,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class EndpointAccessProfile(_Model):
+class EndpointAccessProfile(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Network access profile for Batch endpoint.
:ivar default_action: The default action when there is no IPRule matched. Required. Known
@@ -2431,7 +2472,7 @@ class EndpointDetail(_Model):
"""The port an endpoint is connected to."""
-class EnvironmentSetting(_Model):
+class EnvironmentSetting(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""An environment variable to be set on a task process.
:ivar name: The name of the environment variable. Required.
@@ -2508,7 +2549,7 @@ class ErrorDetail(_Model):
"""The error additional info."""
-class ErrorResponse(_Model):
+class ErrorResponse(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Error response.
:ivar error: The error object.
@@ -2536,7 +2577,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class FixedScaleSettings(_Model):
+class FixedScaleSettings(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Fixed scale settings for the pool.
:ivar resize_timeout: The timeout for allocation of compute nodes to the pool.
@@ -2547,10 +2588,10 @@ class FixedScaleSettings(_Model):
pool.
:vartype target_low_priority_nodes: int
:ivar node_deallocation_option: Determines what to do with a node and its running task(s) after
- it has been selected for deallocation. Known values are: "Requeue", "Terminate",
- "TaskCompletion", and "RetainedData".
+ it has been selected for deallocation. Known values are: "Requeue", "Terminate", and
+ "TaskCompletion".
:vartype node_deallocation_option: str or
- ~azure.mgmt.batch.models.ComputeNodeDeallocationOption
+ ~azure.mgmt.batch.models.RequestedComputeNodeDeallocationOption
"""
resize_timeout: Optional[datetime.timedelta] = rest_field(
@@ -2565,12 +2606,11 @@ class FixedScaleSettings(_Model):
name="targetLowPriorityNodes", visibility=["read", "create", "update", "delete", "query"]
)
"""The desired number of Spot/low-priority compute nodes in the pool."""
- node_deallocation_option: Optional[Union[str, "_models.ComputeNodeDeallocationOption"]] = rest_field(
+ node_deallocation_option: Optional[Union[str, "_models.RequestedComputeNodeDeallocationOption"]] = rest_field(
name="nodeDeallocationOption", visibility=["create", "update"]
)
"""Determines what to do with a node and its running task(s) after it has been selected for
- deallocation. Known values are: \"Requeue\", \"Terminate\", \"TaskCompletion\", and
- \"RetainedData\"."""
+ deallocation. Known values are: \"Requeue\", \"Terminate\", and \"TaskCompletion\"."""
@overload
def __init__(
@@ -2579,7 +2619,7 @@ def __init__(
resize_timeout: Optional[datetime.timedelta] = None,
target_dedicated_nodes: Optional[int] = None,
target_low_priority_nodes: Optional[int] = None,
- node_deallocation_option: Optional[Union[str, "_models.ComputeNodeDeallocationOption"]] = None,
+ node_deallocation_option: Optional[Union[str, "_models.RequestedComputeNodeDeallocationOption"]] = None,
) -> None: ...
@overload
@@ -2593,7 +2633,38 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class HostEndpointSettings(_Model):
+class HardwareProfile(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """Specifies the hardware settings for the compute nodes.
+
+ :ivar vm_size_properties: Specifies the properties for customizing the size of the virtual
+ machine.
+ :vartype vm_size_properties: ~azure.mgmt.batch.models.VmSizeProperties
+ """
+
+ vm_size_properties: Optional["_models.VmSizeProperties"] = rest_field(
+ name="vmSizeProperties", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """Specifies the properties for customizing the size of the virtual machine."""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ vm_size_properties: Optional["_models.VmSizeProperties"] = 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 HostEndpointSettings(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Specifies particular host endpoint settings.
:ivar mode: Specifies the access control policy execution mode. Known values are: "Audit" and
@@ -2635,7 +2706,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class ImageReference(_Model):
+class ImageReference(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""A reference to an Azure Virtual Machines Marketplace image or the Azure Image resource of a
custom Virtual Machine. To get the list of all imageReferences verified by Azure Batch, see the
'List supported node agent SKUs' operation.
@@ -2703,7 +2774,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class InboundNatPool(_Model):
+class InboundNatPool(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""A inbound NAT pool that can be used to address specific ports on compute nodes in a Batch pool
externally.
@@ -2770,7 +2841,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class IPRule(_Model):
+class IPRule(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Rule to filter client IP address.
:ivar action: Action when client IP address is matched. Required. "Allow"
@@ -2803,7 +2874,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class IPTag(_Model):
+class IPTag(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Specifies how tasks should be distributed across compute nodes.
:ivar ip_tag_type: The IP Tag type.
@@ -2838,7 +2909,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class KeyVaultProperties(_Model):
+class KeyVaultProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""KeyVault configuration when using an encryption KeySource of Microsoft.KeyVault.
:ivar key_identifier: Full path to the secret with or without version. Example
@@ -2886,7 +2957,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class KeyVaultReference(_Model):
+class KeyVaultReference(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Identifies the Azure key vault associated with a Batch account.
:ivar id: The resource ID of the Azure key vault associated with the Batch account. Required.
@@ -2919,7 +2990,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class LinuxUserConfiguration(_Model):
+class LinuxUserConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Properties used to create a user account on a Linux node.
:ivar uid: The user ID of the user account.
@@ -2959,7 +3030,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class ManagedDisk(_Model):
+class ManagedDisk(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The managed disk parameters.
:ivar storage_account_type: The storage account type for use in creating data disks or OS disk.
@@ -3007,7 +3078,77 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class MetadataItem(_Model):
+class MaxInstancePercentPerZonePolicy(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """The policy that limits the percentage of pool instances that may be allocated in a single
+ availability zone.
+
+ :ivar enabled: Whether the maximum instance percentage policy is enabled.
+ :vartype enabled: bool
+ :ivar value: The maximum percentage of pool instances that may be allocated in a single
+ availability zone. Required.
+ :vartype value: int
+ """
+
+ enabled: Optional[bool] = rest_field(visibility=["read", "create", "update", "delete", "query"])
+ """Whether the maximum instance percentage policy is enabled."""
+ value: int = rest_field(visibility=["read", "create", "update", "delete", "query"])
+ """The maximum percentage of pool instances that may be allocated in a single availability zone.
+ Required."""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ value: int,
+ enabled: Optional[bool] = 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 MaxInstancePercentPerZonePolicyPatch(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """Per-zone instance percentage fields to update, leaving omitted fields unchanged.
+
+ :ivar enabled: Whether the maximum instance percentage policy is enabled.
+ :vartype enabled: bool
+ :ivar value: The maximum percentage of pool instances that may be allocated in a single
+ availability zone.
+ :vartype value: int
+ """
+
+ enabled: Optional[bool] = rest_field(visibility=["read", "create", "update", "delete", "query"])
+ """Whether the maximum instance percentage policy is enabled."""
+ value: Optional[int] = rest_field(visibility=["read", "create", "update", "delete", "query"])
+ """The maximum percentage of pool instances that may be allocated in a single availability zone."""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ enabled: Optional[bool] = None,
+ value: 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 MetadataItem(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""A name-value pair associated with a Batch service resource.
:ivar name: The name of the metadata item. Required.
@@ -3040,7 +3181,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class MountConfiguration(_Model):
+class MountConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The file system to mount on each node.
:ivar azure_blob_file_system_configuration: The Azure Storage Container to mount using blob
@@ -3093,7 +3234,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class NetworkConfiguration(_Model):
+class NetworkConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The network configuration for a pool.
:ivar subnet_id: The ARM resource identifier of the virtual network subnet which the compute
@@ -3157,7 +3298,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class NetworkProfile(_Model):
+class NetworkProfile(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Network profile for Batch account, which contains network rule settings for each endpoint.
:ivar account_access: Network access profile for batchAccount endpoint (Batch account data
@@ -3197,7 +3338,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class NetworkSecurityGroupRule(_Model):
+class NetworkSecurityGroupRule(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""A network security group rule to apply to an inbound endpoint.
:ivar priority: The priority for this rule. Required.
@@ -3248,7 +3389,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class NetworkSecurityPerimeter(_Model):
+class NetworkSecurityPerimeter(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Information about a network security perimeter (NSP).
:ivar id: Fully qualified Azure resource ID of the NSP resource.
@@ -3288,7 +3429,9 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class NetworkSecurityPerimeterConfiguration(ProxyResource):
+class NetworkSecurityPerimeterConfiguration(
+ ProxyResource
+): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Network security perimeter (NSP) configuration resource.
:ivar id: Fully qualified resource ID for the resource. Ex -
@@ -3302,13 +3445,14 @@ class NetworkSecurityPerimeterConfiguration(ProxyResource):
:ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy
information.
:vartype system_data: ~azure.mgmt.batch.models.SystemData
- :ivar properties:
+ :ivar properties: Network security configuration properties.
:vartype properties: ~azure.mgmt.batch.models.NetworkSecurityPerimeterConfigurationProperties
"""
properties: Optional["_models.NetworkSecurityPerimeterConfigurationProperties"] = rest_field(
visibility=["read", "create", "update", "delete", "query"]
)
+ """Network security configuration properties."""
@overload
def __init__(
@@ -3328,28 +3472,32 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class NetworkSecurityPerimeterConfigurationProperties(_Model): # pylint: disable=name-too-long
+class NetworkSecurityPerimeterConfigurationProperties(
+ _Model
+): # pylint: disable=name-too-long,docstring-keyword-should-match-keyword-only
"""Network security configuration properties.
- :ivar provisioning_state: Known values are: "Succeeded", "Creating", "Updating", "Deleting",
- "Accepted", "Failed", and "Canceled".
+ :ivar provisioning_state: Provisioning state of the network security perimeter configuration.
+ Known values are: "Succeeded", "Creating", "Updating", "Deleting", "Accepted", "Failed", and
+ "Canceled".
:vartype provisioning_state: str or
~azure.mgmt.batch.models.NetworkSecurityPerimeterConfigurationProvisioningState
:ivar provisioning_issues: List of provisioning issues, if any.
:vartype provisioning_issues: list[~azure.mgmt.batch.models.ProvisioningIssue]
- :ivar network_security_perimeter:
+ :ivar network_security_perimeter: Information about the network security perimeter (NSP).
:vartype network_security_perimeter: ~azure.mgmt.batch.models.NetworkSecurityPerimeter
- :ivar resource_association:
+ :ivar resource_association: Information about the resource association.
:vartype resource_association: ~azure.mgmt.batch.models.ResourceAssociation
- :ivar profile:
+ :ivar profile: Network security perimeter configuration profile.
:vartype profile: ~azure.mgmt.batch.models.NetworkSecurityProfile
"""
provisioning_state: Optional[Union[str, "_models.NetworkSecurityPerimeterConfigurationProvisioningState"]] = (
rest_field(name="provisioningState", visibility=["read"])
)
- """Known values are: \"Succeeded\", \"Creating\", \"Updating\", \"Deleting\", \"Accepted\",
- \"Failed\", and \"Canceled\"."""
+ """Provisioning state of the network security perimeter configuration. Known values are:
+ \"Succeeded\", \"Creating\", \"Updating\", \"Deleting\", \"Accepted\", \"Failed\", and
+ \"Canceled\"."""
provisioning_issues: Optional[list["_models.ProvisioningIssue"]] = rest_field(
name="provisioningIssues", visibility=["read"]
)
@@ -3357,12 +3505,15 @@ class NetworkSecurityPerimeterConfigurationProperties(_Model): # pylint: disabl
network_security_perimeter: Optional["_models.NetworkSecurityPerimeter"] = rest_field(
name="networkSecurityPerimeter", visibility=["read", "create", "update", "delete", "query"]
)
+ """Information about the network security perimeter (NSP)."""
resource_association: Optional["_models.ResourceAssociation"] = rest_field(
name="resourceAssociation", visibility=["read", "create", "update", "delete", "query"]
)
+ """Information about the resource association."""
profile: Optional["_models.NetworkSecurityProfile"] = rest_field(
visibility=["read", "create", "update", "delete", "query"]
)
+ """Network security perimeter configuration profile."""
@overload
def __init__(
@@ -3384,7 +3535,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class NetworkSecurityProfile(_Model):
+class NetworkSecurityProfile(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Network security perimeter configuration profile.
:ivar name: Name of the profile.
@@ -3440,7 +3591,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class NFSMountConfiguration(_Model):
+class NFSMountConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Information used to connect to an NFS file system.
:ivar source: The URI of the file system to mount. Required.
@@ -3483,7 +3634,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class NodePlacementConfiguration(_Model):
+class NodePlacementConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Node placement configuration for Batch pools.
:ivar policy: Node placement Policy type on Batch pools. Known values are: "Regional" and
@@ -3514,7 +3665,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class Operation(_Model):
+class Operation(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""A REST API operation.
:ivar name: The operation name.
@@ -3566,7 +3717,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class OperationDisplay(_Model):
+class OperationDisplay(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The object that describes the operation.
:ivar provider: Friendly name of the resource provider.
@@ -3609,7 +3760,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class OSDisk(_Model):
+class OSDisk(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Settings for the operating system disk of the virtual machine.
:ivar ephemeral_os_disk_settings: Specifies the ephemeral Disk Settings for the operating
@@ -3689,7 +3840,70 @@ class OutboundEnvironmentEndpoint(_Model):
"""The endpoints for this service to which the Batch service makes outbound calls."""
-class Pool(ProxyResource):
+class Placement(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """The placement policy for compute nodes in a pool.
+
+ :ivar zone_placement_policy: Auto delegates zone selection and balancing to the virtual machine
+ scale set. Required. "Auto"
+ :vartype zone_placement_policy: str or ~azure.mgmt.batch.models.ZonePlacementPolicyType
+ """
+
+ zone_placement_policy: Union[str, "_models.ZonePlacementPolicyType"] = rest_field(
+ name="zonePlacementPolicy", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """Auto delegates zone selection and balancing to the virtual machine scale set. Required.
+ \"Auto\""""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ zone_placement_policy: Union[str, "_models.ZonePlacementPolicyType"],
+ ) -> 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 PlacementPatch(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """Availability zone placement fields to update, leaving omitted fields unchanged.
+
+ :ivar zone_placement_policy: Auto delegates zone selection and balancing to the virtual machine
+ scale set. "Auto"
+ :vartype zone_placement_policy: str or ~azure.mgmt.batch.models.ZonePlacementPolicyType
+ """
+
+ zone_placement_policy: Optional[Union[str, "_models.ZonePlacementPolicyType"]] = rest_field(
+ name="zonePlacementPolicy", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """Auto delegates zone selection and balancing to the virtual machine scale set. \"Auto\""""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ zone_placement_policy: Optional[Union[str, "_models.ZonePlacementPolicyType"]] = 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 Pool(ProxyResource): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Contains information about a pool.
:ivar id: Fully qualified resource ID for the resource. Ex -
@@ -3735,6 +3949,7 @@ class Pool(ProxyResource):
"allocation_state",
"allocation_state_transition_time",
"vm_size",
+ "vm_sku_profile",
"deployment_configuration",
"current_dedicated_nodes",
"current_low_priority_nodes",
@@ -3791,7 +4006,7 @@ def __setattr__(self, key: str, value: Any) -> None:
super().__setattr__(key, value)
-class PoolEndpointConfiguration(_Model):
+class PoolEndpointConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The endpoint configuration for a pool.
:ivar inbound_nat_pools: A list of inbound NAT pools that can be used to address specific ports
@@ -3823,8 +4038,65 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class PoolProperties(_Model):
- """Pool properties.
+class PoolPatch(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """Properties supplied when updating a pool.
+
+ :ivar identity: The type of identity used for the Batch Pool.
+ :vartype identity: ~azure.mgmt.batch.models.BatchPoolIdentity
+ :ivar etag: The ETag of the resource, used for concurrency statements.
+ :vartype etag: str
+ :ivar tags: The tags of the resource.
+ :vartype tags: dict[str, str]
+ :ivar id: Fully qualified resource ID for the resource. Ex -
+ /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
+ :vartype id: str
+ :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy
+ information.
+ :vartype system_data: ~azure.mgmt.batch.models.SystemData
+ :ivar properties: The pool properties to update.
+ :vartype properties: ~azure.mgmt.batch.models.PoolPatchProperties
+ """
+
+ identity: Optional["_models.BatchPoolIdentity"] = rest_field(
+ visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The type of identity used for the Batch Pool."""
+ etag: Optional[str] = rest_field(visibility=["read"])
+ """The ETag of the resource, used for concurrency statements."""
+ tags: Optional[dict[str, str]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
+ """The tags of the resource."""
+ id: Optional[str] = rest_field(visibility=["read"])
+ """Fully qualified resource ID for the resource. Ex -
+ /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}."""
+ system_data: Optional["_models.SystemData"] = rest_field(name="systemData", visibility=["read"])
+ """Azure Resource Manager metadata containing createdBy and modifiedBy information."""
+ properties: Optional["_models.PoolPatchProperties"] = rest_field(
+ visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The pool properties to update."""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ identity: Optional["_models.BatchPoolIdentity"] = None,
+ tags: Optional[dict[str, str]] = None,
+ properties: Optional["_models.PoolPatchProperties"] = 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 PoolPatchProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """Pool settings with partial updates for the new zone policies.
:ivar display_name: The display name for the pool.
:vartype display_name: str
@@ -3845,9 +4117,10 @@ class PoolProperties(_Model):
:vartype allocation_state_transition_time: ~datetime.datetime
:ivar vm_size: The size of virtual machines in the pool. All VMs in a pool are the same size.
:vartype vm_size: str
- :ivar deployment_configuration: This property describes the virtual machines that the pool
- nodes will be deployed on.
- :vartype deployment_configuration: ~azure.mgmt.batch.models.DeploymentConfiguration
+ :ivar vm_sku_profile: Specifies the profile of VM sizes and the allocation strategy used to
+ allocate compute nodes for an Instance Mix pool. When specified, vmSize must be "Mix". This
+ property can only be changed while the pool has no compute nodes.
+ :vartype vm_sku_profile: ~azure.mgmt.batch.models.VirtualMachineSkuProfile
:ivar current_dedicated_nodes: The number of dedicated compute nodes currently in the pool.
:vartype current_dedicated_nodes: int
:ivar current_low_priority_nodes: The number of Spot/low-priority compute nodes currently in
@@ -3862,9 +4135,6 @@ class PoolProperties(_Model):
:vartype inter_node_communication: str or ~azure.mgmt.batch.models.InterNodeCommunicationState
:ivar network_configuration: The network configuration for the pool.
:vartype network_configuration: ~azure.mgmt.batch.models.NetworkConfiguration
- :ivar task_slots_per_node: The number of task slots that can be used to run concurrent tasks on
- a single compute node in the pool.
- :vartype task_slots_per_node: int
:ivar task_scheduling_policy: How tasks are distributed across compute nodes in a pool.
:vartype task_scheduling_policy: ~azure.mgmt.batch.models.TaskSchedulingPolicy
:ivar user_accounts: The list of user accounts to be created on each node in the pool.
@@ -3883,6 +4153,12 @@ class PoolProperties(_Model):
:vartype mount_configuration: list[~azure.mgmt.batch.models.MountConfiguration]
:ivar upgrade_policy: The upgrade policy for the pool.
:vartype upgrade_policy: ~azure.mgmt.batch.models.UpgradePolicy
+ :ivar deployment_configuration: This property describes the virtual machines that the pool
+ nodes will be deployed on.
+ :vartype deployment_configuration: ~azure.mgmt.batch.models.DeploymentConfigurationPatch
+ :ivar task_slots_per_node: The number of task slots that can be used to run concurrent tasks on
+ a single compute node in the pool.
+ :vartype task_slots_per_node: int
"""
display_name: Optional[str] = rest_field(
@@ -3911,10 +4187,12 @@ class PoolProperties(_Model):
"""The time at which the pool entered its current allocation state."""
vm_size: Optional[str] = rest_field(name="vmSize", visibility=["read", "create", "update", "delete", "query"])
"""The size of virtual machines in the pool. All VMs in a pool are the same size."""
- deployment_configuration: Optional["_models.DeploymentConfiguration"] = rest_field(
- name="deploymentConfiguration", visibility=["read", "create", "update", "delete", "query"]
+ vm_sku_profile: Optional["_models.VirtualMachineSkuProfile"] = rest_field(
+ name="vmSkuProfile", visibility=["read", "create", "update", "delete", "query"]
)
- """This property describes the virtual machines that the pool nodes will be deployed on."""
+ """Specifies the profile of VM sizes and the allocation strategy used to allocate compute nodes
+ for an Instance Mix pool. When specified, vmSize must be \"Mix\". This property can only be
+ changed while the pool has no compute nodes."""
current_dedicated_nodes: Optional[int] = rest_field(name="currentDedicatedNodes", visibility=["read"])
"""The number of dedicated compute nodes currently in the pool."""
current_low_priority_nodes: Optional[int] = rest_field(name="currentLowPriorityNodes", visibility=["read"])
@@ -3934,11 +4212,6 @@ class PoolProperties(_Model):
name="networkConfiguration", visibility=["read", "create", "update", "delete", "query"]
)
"""The network configuration for the pool."""
- task_slots_per_node: Optional[int] = rest_field(
- name="taskSlotsPerNode", visibility=["read", "create", "update", "delete", "query"]
- )
- """The number of task slots that can be used to run concurrent tasks on a single compute node in
- the pool."""
task_scheduling_policy: Optional["_models.TaskSchedulingPolicy"] = rest_field(
name="taskSchedulingPolicy", visibility=["read", "create", "update", "delete", "query"]
)
@@ -3971,6 +4244,15 @@ class PoolProperties(_Model):
name="upgradePolicy", visibility=["read", "create", "update", "delete", "query"]
)
"""The upgrade policy for the pool."""
+ deployment_configuration: Optional["_models.DeploymentConfigurationPatch"] = rest_field(
+ name="deploymentConfiguration", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """This property describes the virtual machines that the pool nodes will be deployed on."""
+ task_slots_per_node: Optional[int] = rest_field(
+ name="taskSlotsPerNode", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The number of task slots that can be used to run concurrent tasks on a single compute node in
+ the pool."""
@overload
def __init__(
@@ -3978,11 +4260,10 @@ def __init__(
*,
display_name: Optional[str] = None,
vm_size: Optional[str] = None,
- deployment_configuration: Optional["_models.DeploymentConfiguration"] = None,
+ vm_sku_profile: Optional["_models.VirtualMachineSkuProfile"] = None,
scale_settings: Optional["_models.ScaleSettings"] = None,
inter_node_communication: Optional[Union[str, "_models.InterNodeCommunicationState"]] = None,
network_configuration: Optional["_models.NetworkConfiguration"] = None,
- task_slots_per_node: Optional[int] = None,
task_scheduling_policy: Optional["_models.TaskSchedulingPolicy"] = None,
user_accounts: Optional[list["_models.UserAccount"]] = None,
metadata: Optional[list["_models.MetadataItem"]] = None,
@@ -3990,6 +4271,8 @@ def __init__(
application_packages: Optional[list["_models.ApplicationPackageReference"]] = None,
mount_configuration: Optional[list["_models.MountConfiguration"]] = None,
upgrade_policy: Optional["_models.UpgradePolicy"] = None,
+ deployment_configuration: Optional["_models.DeploymentConfigurationPatch"] = None,
+ task_slots_per_node: Optional[int] = None,
) -> None: ...
@overload
@@ -4003,34 +4286,225 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class PrivateEndpoint(_Model):
- """The private endpoint of the private endpoint connection.
-
- :ivar id: The ARM resource identifier of the private endpoint. This is of the form
- /subscriptions/{subscription}/resourceGroups/{group}/providers/Microsoft.Network/privateEndpoints/{privateEndpoint}.
- :vartype id: str
- """
-
- id: Optional[str] = rest_field(visibility=["read"])
- """The ARM resource identifier of the private endpoint. This is of the form
- /subscriptions/{subscription}/resourceGroups/{group}/providers/Microsoft.Network/privateEndpoints/{privateEndpoint}."""
-
-
-class PrivateEndpointConnection(ProxyResource):
- """Contains information about a private link resource.
+class PoolProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """Pool properties.
- :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.batch.models.SystemData
- :ivar properties: The properties associated with the private endpoint connection.
+ :ivar display_name: The display name for the pool.
+ :vartype display_name: str
+ :ivar last_modified: The last modified time of the pool.
+ :vartype last_modified: ~datetime.datetime
+ :ivar creation_time: The creation time of the pool.
+ :vartype creation_time: ~datetime.datetime
+ :ivar provisioning_state: The current state of the pool. Known values are: "Succeeded" and
+ "Deleting".
+ :vartype provisioning_state: str or ~azure.mgmt.batch.models.PoolProvisioningState
+ :ivar provisioning_state_transition_time: The time at which the pool entered its current state.
+ :vartype provisioning_state_transition_time: ~datetime.datetime
+ :ivar allocation_state: Whether the pool is resizing. Known values are: "Steady", "Resizing",
+ and "Stopping".
+ :vartype allocation_state: str or ~azure.mgmt.batch.models.AllocationState
+ :ivar allocation_state_transition_time: The time at which the pool entered its current
+ allocation state.
+ :vartype allocation_state_transition_time: ~datetime.datetime
+ :ivar vm_size: The size of virtual machines in the pool. All VMs in a pool are the same size.
+ :vartype vm_size: str
+ :ivar vm_sku_profile: Specifies the profile of VM sizes and the allocation strategy used to
+ allocate compute nodes for an Instance Mix pool. When specified, vmSize must be "Mix". This
+ property can only be changed while the pool has no compute nodes.
+ :vartype vm_sku_profile: ~azure.mgmt.batch.models.VirtualMachineSkuProfile
+ :ivar deployment_configuration: This property describes the virtual machines that the pool
+ nodes will be deployed on.
+ :vartype deployment_configuration: ~azure.mgmt.batch.models.DeploymentConfiguration
+ :ivar current_dedicated_nodes: The number of dedicated compute nodes currently in the pool.
+ :vartype current_dedicated_nodes: int
+ :ivar current_low_priority_nodes: The number of Spot/low-priority compute nodes currently in
+ the pool.
+ :vartype current_low_priority_nodes: int
+ :ivar scale_settings: Settings which configure the number of nodes in the pool.
+ :vartype scale_settings: ~azure.mgmt.batch.models.ScaleSettings
+ :ivar auto_scale_run: The results and errors from the last execution of the autoscale formula.
+ :vartype auto_scale_run: ~azure.mgmt.batch.models.AutoScaleRun
+ :ivar inter_node_communication: Whether the pool permits direct communication between nodes.
+ Known values are: "Enabled" and "Disabled".
+ :vartype inter_node_communication: str or ~azure.mgmt.batch.models.InterNodeCommunicationState
+ :ivar network_configuration: The network configuration for the pool.
+ :vartype network_configuration: ~azure.mgmt.batch.models.NetworkConfiguration
+ :ivar task_slots_per_node: The number of task slots that can be used to run concurrent tasks on
+ a single compute node in the pool.
+ :vartype task_slots_per_node: int
+ :ivar task_scheduling_policy: How tasks are distributed across compute nodes in a pool.
+ :vartype task_scheduling_policy: ~azure.mgmt.batch.models.TaskSchedulingPolicy
+ :ivar user_accounts: The list of user accounts to be created on each node in the pool.
+ :vartype user_accounts: list[~azure.mgmt.batch.models.UserAccount]
+ :ivar metadata: A list of name-value pairs associated with the pool as metadata.
+ :vartype metadata: list[~azure.mgmt.batch.models.MetadataItem]
+ :ivar start_task: A task specified to run on each compute node as it joins the pool.
+ :vartype start_task: ~azure.mgmt.batch.models.StartTask
+ :ivar application_packages: The list of application packages to be installed on each compute
+ node in the pool.
+ :vartype application_packages: list[~azure.mgmt.batch.models.ApplicationPackageReference]
+ :ivar resize_operation_status: Contains details about the current or last completed resize
+ operation.
+ :vartype resize_operation_status: ~azure.mgmt.batch.models.ResizeOperationStatus
+ :ivar mount_configuration: A list of file systems to mount on each node in the pool.
+ :vartype mount_configuration: list[~azure.mgmt.batch.models.MountConfiguration]
+ :ivar upgrade_policy: The upgrade policy for the pool.
+ :vartype upgrade_policy: ~azure.mgmt.batch.models.UpgradePolicy
+ """
+
+ display_name: Optional[str] = rest_field(
+ name="displayName", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The display name for the pool."""
+ last_modified: Optional[datetime.datetime] = rest_field(name="lastModified", visibility=["read"], format="rfc3339")
+ """The last modified time of the pool."""
+ creation_time: Optional[datetime.datetime] = rest_field(name="creationTime", visibility=["read"], format="rfc3339")
+ """The creation time of the pool."""
+ provisioning_state: Optional[Union[str, "_models.PoolProvisioningState"]] = rest_field(
+ name="provisioningState", visibility=["read"]
+ )
+ """The current state of the pool. Known values are: \"Succeeded\" and \"Deleting\"."""
+ provisioning_state_transition_time: Optional[datetime.datetime] = rest_field(
+ name="provisioningStateTransitionTime", visibility=["read"], format="rfc3339"
+ )
+ """The time at which the pool entered its current state."""
+ allocation_state: Optional[Union[str, "_models.AllocationState"]] = rest_field(
+ name="allocationState", visibility=["read"]
+ )
+ """Whether the pool is resizing. Known values are: \"Steady\", \"Resizing\", and \"Stopping\"."""
+ allocation_state_transition_time: Optional[datetime.datetime] = rest_field(
+ name="allocationStateTransitionTime", visibility=["read"], format="rfc3339"
+ )
+ """The time at which the pool entered its current allocation state."""
+ vm_size: Optional[str] = rest_field(name="vmSize", visibility=["read", "create", "update", "delete", "query"])
+ """The size of virtual machines in the pool. All VMs in a pool are the same size."""
+ vm_sku_profile: Optional["_models.VirtualMachineSkuProfile"] = rest_field(
+ name="vmSkuProfile", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """Specifies the profile of VM sizes and the allocation strategy used to allocate compute nodes
+ for an Instance Mix pool. When specified, vmSize must be \"Mix\". This property can only be
+ changed while the pool has no compute nodes."""
+ deployment_configuration: Optional["_models.DeploymentConfiguration"] = rest_field(
+ name="deploymentConfiguration", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """This property describes the virtual machines that the pool nodes will be deployed on."""
+ current_dedicated_nodes: Optional[int] = rest_field(name="currentDedicatedNodes", visibility=["read"])
+ """The number of dedicated compute nodes currently in the pool."""
+ current_low_priority_nodes: Optional[int] = rest_field(name="currentLowPriorityNodes", visibility=["read"])
+ """The number of Spot/low-priority compute nodes currently in the pool."""
+ scale_settings: Optional["_models.ScaleSettings"] = rest_field(
+ name="scaleSettings", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """Settings which configure the number of nodes in the pool."""
+ auto_scale_run: Optional["_models.AutoScaleRun"] = rest_field(name="autoScaleRun", visibility=["read"])
+ """The results and errors from the last execution of the autoscale formula."""
+ inter_node_communication: Optional[Union[str, "_models.InterNodeCommunicationState"]] = rest_field(
+ name="interNodeCommunication", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """Whether the pool permits direct communication between nodes. Known values are: \"Enabled\" and
+ \"Disabled\"."""
+ network_configuration: Optional["_models.NetworkConfiguration"] = rest_field(
+ name="networkConfiguration", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The network configuration for the pool."""
+ task_slots_per_node: Optional[int] = rest_field(
+ name="taskSlotsPerNode", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The number of task slots that can be used to run concurrent tasks on a single compute node in
+ the pool."""
+ task_scheduling_policy: Optional["_models.TaskSchedulingPolicy"] = rest_field(
+ name="taskSchedulingPolicy", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """How tasks are distributed across compute nodes in a pool."""
+ user_accounts: Optional[list["_models.UserAccount"]] = rest_field(
+ name="userAccounts", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The list of user accounts to be created on each node in the pool."""
+ metadata: Optional[list["_models.MetadataItem"]] = rest_field(
+ visibility=["read", "create", "update", "delete", "query"]
+ )
+ """A list of name-value pairs associated with the pool as metadata."""
+ start_task: Optional["_models.StartTask"] = rest_field(
+ name="startTask", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """A task specified to run on each compute node as it joins the pool."""
+ application_packages: Optional[list["_models.ApplicationPackageReference"]] = rest_field(
+ name="applicationPackages", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The list of application packages to be installed on each compute node in the pool."""
+ resize_operation_status: Optional["_models.ResizeOperationStatus"] = rest_field(
+ name="resizeOperationStatus", visibility=["read"]
+ )
+ """Contains details about the current or last completed resize operation."""
+ mount_configuration: Optional[list["_models.MountConfiguration"]] = rest_field(
+ name="mountConfiguration", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """A list of file systems to mount on each node in the pool."""
+ upgrade_policy: Optional["_models.UpgradePolicy"] = rest_field(
+ name="upgradePolicy", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The upgrade policy for the pool."""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ display_name: Optional[str] = None,
+ vm_size: Optional[str] = None,
+ vm_sku_profile: Optional["_models.VirtualMachineSkuProfile"] = None,
+ deployment_configuration: Optional["_models.DeploymentConfiguration"] = None,
+ scale_settings: Optional["_models.ScaleSettings"] = None,
+ inter_node_communication: Optional[Union[str, "_models.InterNodeCommunicationState"]] = None,
+ network_configuration: Optional["_models.NetworkConfiguration"] = None,
+ task_slots_per_node: Optional[int] = None,
+ task_scheduling_policy: Optional["_models.TaskSchedulingPolicy"] = None,
+ user_accounts: Optional[list["_models.UserAccount"]] = None,
+ metadata: Optional[list["_models.MetadataItem"]] = None,
+ start_task: Optional["_models.StartTask"] = None,
+ application_packages: Optional[list["_models.ApplicationPackageReference"]] = None,
+ mount_configuration: Optional[list["_models.MountConfiguration"]] = None,
+ upgrade_policy: Optional["_models.UpgradePolicy"] = 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 PrivateEndpoint(_Model):
+ """The private endpoint of the private endpoint connection.
+
+ :ivar id: The ARM resource identifier of the private endpoint. This is of the form
+ /subscriptions/{subscription}/resourceGroups/{group}/providers/Microsoft.Network/privateEndpoints/{privateEndpoint}.
+ :vartype id: str
+ """
+
+ id: Optional[str] = rest_field(visibility=["read"])
+ """The ARM resource identifier of the private endpoint. This is of the form
+ /subscriptions/{subscription}/resourceGroups/{group}/providers/Microsoft.Network/privateEndpoints/{privateEndpoint}."""
+
+
+class PrivateEndpointConnection(ProxyResource): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """Contains information about a private link resource.
+
+ :ivar id: Fully qualified resource ID for the resource. Ex -
+ /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
+ :vartype id: str
+ :ivar name: The name of the resource.
+ :vartype name: str
+ :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
+ "Microsoft.Storage/storageAccounts".
+ :vartype type: str
+ :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy
+ information.
+ :vartype system_data: ~azure.mgmt.batch.models.SystemData
+ :ivar properties: The properties associated with the private endpoint connection.
:vartype properties: ~azure.mgmt.batch.models.PrivateEndpointConnectionProperties
:ivar etag: The ETag of the resource, used for concurrency statements.
:vartype etag: str
@@ -4086,7 +4560,7 @@ def __setattr__(self, key: str, value: Any) -> None:
super().__setattr__(key, value)
-class PrivateEndpointConnectionProperties(_Model):
+class PrivateEndpointConnectionProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Private endpoint connection properties.
:ivar provisioning_state: The provisioning state of the private endpoint connection. Known
@@ -4135,7 +4609,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class PrivateLinkResource(ProxyResource):
+class PrivateLinkResource(ProxyResource): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Contains information about a private link resource.
:ivar id: Fully qualified resource ID for the resource. Ex -
@@ -4225,7 +4699,7 @@ class PrivateLinkResourceProperties(_Model):
"""The list of required zone names for the private DNS resource name."""
-class PrivateLinkServiceConnectionState(_Model):
+class PrivateLinkServiceConnectionState(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The private link service connection state of the private endpoint connection.
:ivar status: The status of the Batch private endpoint connection. Required. Known values are:
@@ -4271,13 +4745,14 @@ class ProvisioningIssue(_Model):
:ivar name: Name of the issue.
:vartype name: str
- :ivar properties:
+ :ivar properties: Details of the provisioning issue.
:vartype properties: ~azure.mgmt.batch.models.ProvisioningIssueProperties
"""
name: Optional[str] = rest_field(visibility=["read"])
"""Name of the issue."""
properties: Optional["_models.ProvisioningIssueProperties"] = rest_field(visibility=["read"])
+ """Details of the provisioning issue."""
class ProvisioningIssueProperties(_Model):
@@ -4318,7 +4793,7 @@ class ProvisioningIssueProperties(_Model):
"""Access rules that can be added to the network security profile (NSP) to remediate the issue."""
-class ProxyAgentSettings(_Model):
+class ProxyAgentSettings(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Specifies ProxyAgent settings while creating the virtual machine.
:ivar enabled: Specifies whether Metadata Security Protocol feature should be enabled on the
@@ -4362,7 +4837,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class PublicIPAddressConfiguration(_Model):
+class PublicIPAddressConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The public IP Address configuration of the networking configuration of a Pool.
:ivar provision: The provisioning type for Public IP Addresses for the Batch Pool. Known values
@@ -4416,7 +4891,68 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class ResizeError(_Model):
+class ResiliencyPolicy(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """The resiliency policy for compute nodes in a pool.
+
+ :ivar zone_allocation_policy: The policy that controls allocation across availability zones.
+ Required.
+ :vartype zone_allocation_policy: ~azure.mgmt.batch.models.ZoneAllocationPolicy
+ """
+
+ zone_allocation_policy: "_models.ZoneAllocationPolicy" = rest_field(
+ name="zoneAllocationPolicy", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The policy that controls allocation across availability zones. Required."""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ zone_allocation_policy: "_models.ZoneAllocationPolicy",
+ ) -> 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 ResiliencyPolicyPatch(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """Resiliency policy fields to update, leaving omitted fields unchanged.
+
+ :ivar zone_allocation_policy: The zone allocation policy fields to update.
+ :vartype zone_allocation_policy: ~azure.mgmt.batch.models.ZoneAllocationPolicyPatch
+ """
+
+ zone_allocation_policy: Optional["_models.ZoneAllocationPolicyPatch"] = rest_field(
+ name="zoneAllocationPolicy", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The zone allocation policy fields to update."""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ zone_allocation_policy: Optional["_models.ZoneAllocationPolicyPatch"] = 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 ResizeError(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""An error that occurred when resizing a pool.
:ivar code: An identifier for the error. Codes are invariant and are intended to be consumed
@@ -4460,7 +4996,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class ResizeOperationStatus(_Model):
+class ResizeOperationStatus(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Details about the current or last completed resize operation.
:ivar target_dedicated_nodes: The desired number of dedicated compute nodes in the pool.
@@ -4533,12 +5069,13 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class ResourceAssociation(_Model):
+class ResourceAssociation(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Information about resource association.
:ivar name: Name of the resource association.
:vartype name: str
- :ivar access_mode: Known values are: "Enforced", "Learning", and "Audit".
+ :ivar access_mode: Access mode of the resource association. Known values are: "Enforced",
+ "Learning", and "Audit".
:vartype access_mode: str or ~azure.mgmt.batch.models.ResourceAssociationAccessMode
"""
@@ -4547,7 +5084,8 @@ class ResourceAssociation(_Model):
access_mode: Optional[Union[str, "_models.ResourceAssociationAccessMode"]] = rest_field(
name="accessMode", visibility=["read", "create", "update", "delete", "query"]
)
- """Known values are: \"Enforced\", \"Learning\", and \"Audit\"."""
+ """Access mode of the resource association. Known values are: \"Enforced\", \"Learning\", and
+ \"Audit\"."""
@overload
def __init__(
@@ -4568,7 +5106,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class ResourceFile(_Model):
+class ResourceFile(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""A single file or multiple files to be downloaded to a compute node.
:ivar auto_storage_container_name: The storage container name in the auto storage account.
@@ -4640,15 +5178,15 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class RollingUpgradePolicy(_Model):
+class RollingUpgradePolicy(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The configuration parameters used while performing a rolling upgrade.
:ivar enable_cross_zone_upgrade: Allow VMSS to ignore AZ boundaries when constructing upgrade
batches. Take into consideration the Update Domain and maxBatchInstancePercent to determine the
batch size. If this field is not set, Azure Azure Batch will not set its default value. The
value of enableCrossZoneUpgrade on the created VirtualMachineScaleSet will be decided by the
- default configurations on VirtualMachineScaleSet. This field is able to be set to true or false
- only when using NodePlacementConfiguration as Zonal.
+ default configurations on VirtualMachineScaleSet. This field can be set to true or false only
+ when nodePlacementConfiguration.policy is Zonal or placement.zonePlacementPolicy is Auto.
:vartype enable_cross_zone_upgrade: bool
:ivar max_batch_instance_percent: The maximum percent of total virtual machine instances that
will be upgraded simultaneously by the rolling upgrade in one batch. As this is a maximum,
@@ -4690,8 +5228,8 @@ class RollingUpgradePolicy(_Model):
the Update Domain and maxBatchInstancePercent to determine the batch size. If this field is not
set, Azure Azure Batch will not set its default value. The value of enableCrossZoneUpgrade on
the created VirtualMachineScaleSet will be decided by the default configurations on
- VirtualMachineScaleSet. This field is able to be set to true or false only when using
- NodePlacementConfiguration as Zonal."""
+ VirtualMachineScaleSet. This field can be set to true or false only when
+ nodePlacementConfiguration.policy is Zonal or placement.zonePlacementPolicy is Auto."""
max_batch_instance_percent: Optional[int] = rest_field(
name="maxBatchInstancePercent", visibility=["read", "create", "update", "delete", "query"]
)
@@ -4756,7 +5294,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class ScaleSettings(_Model):
+class ScaleSettings(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Scale settings for the pool.
:ivar fixed_scale: Fixed scale settings for the pool.
@@ -4793,7 +5331,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class SecurityProfile(_Model):
+class SecurityProfile(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Specifies the security profile settings for the virtual machine or virtual machine scale set.
:ivar security_type: Specifies the SecurityType of the virtual machine. It has to be set to any
@@ -4852,7 +5390,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class ServiceArtifactReference(_Model):
+class ServiceArtifactReference(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Specifies the service artifact reference id used to set same image version for all virtual
machines in the scale set when using 'latest' image version.
@@ -4896,7 +5434,7 @@ class SkuCapability(_Model):
"""The value of the feature."""
-class StartTask(_Model):
+class StartTask(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""A task which is run when a compute node joins a pool in the Azure Batch service, or when the
compute node is rebooted or reimaged.
@@ -4999,7 +5537,7 @@ class SupportedSku(_Model):
"""The time when Azure Batch service will retire this SKU."""
-class SystemData(_Model):
+class SystemData(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Metadata pertaining to creation and last modification of the resource.
:ivar created_by: The identity that created the resource.
@@ -5066,7 +5604,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class TaskContainerSettings(_Model):
+class TaskContainerSettings(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The container settings for a task.
:ivar container_run_options: Additional options to the container create command.
@@ -5128,7 +5666,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class TaskSchedulingPolicy(_Model):
+class TaskSchedulingPolicy(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Specifies how tasks should be distributed across compute nodes.
:ivar job_default_order: If not specified, the default is none. Known values are: "None" and
@@ -5168,7 +5706,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class UefiSettings(_Model):
+class UefiSettings(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Specifies the security settings like secure boot and vTPM used while creating the virtual
machine.
@@ -5207,7 +5745,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class UpgradePolicy(_Model):
+class UpgradePolicy(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Describes an upgrade policy - automatic, manual, or rolling.
:ivar mode: Specifies the mode of an upgrade to virtual machines in the scale set.
@@ -5261,7 +5799,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class UserAccount(_Model):
+class UserAccount(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Properties used to create a user on an Azure Batch node.
:ivar name: The name of the user account. Names can contain any Unicode characters up to a
@@ -5333,7 +5871,7 @@ class UserAssignedIdentities(_Model):
"""The client id of user assigned identity."""
-class UserIdentity(_Model):
+class UserIdentity(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The definition of the user identity under which the task is run.
:ivar user_name: The name of the user identity under which the task is run.
@@ -5368,7 +5906,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class VirtualMachineConfiguration(_Model):
+class VirtualMachineConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The configuration for compute nodes in a pool based on the Azure Virtual Machines
infrastructure.
@@ -5401,6 +5939,12 @@ class VirtualMachineConfiguration(_Model):
:ivar service_artifact_reference: Specifies the service artifact reference id used to set same
image version for all virtual machines in the scale set when using 'latest' image version.
:vartype service_artifact_reference: ~azure.mgmt.batch.models.ServiceArtifactReference
+ :ivar hardware_profile: Specifies the hardware settings for the compute nodes.
+ :vartype hardware_profile: ~azure.mgmt.batch.models.HardwareProfile
+ :ivar placement: The availability zone placement policy for compute nodes in the pool.
+ :vartype placement: ~azure.mgmt.batch.models.Placement
+ :ivar resiliency_policy: The resiliency policy for compute nodes in the pool.
+ :vartype resiliency_policy: ~azure.mgmt.batch.models.ResiliencyPolicy
"""
image_reference: "_models.ImageReference" = rest_field(
@@ -5453,6 +5997,16 @@ class VirtualMachineConfiguration(_Model):
)
"""Specifies the service artifact reference id used to set same image version for all virtual
machines in the scale set when using 'latest' image version."""
+ hardware_profile: Optional["_models.HardwareProfile"] = rest_field(
+ name="hardwareProfile", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """Specifies the hardware settings for the compute nodes."""
+ placement: Optional["_models.Placement"] = rest_field(visibility=["read", "create", "update", "delete", "query"])
+ """The availability zone placement policy for compute nodes in the pool."""
+ resiliency_policy: Optional["_models.ResiliencyPolicy"] = rest_field(
+ name="resiliencyPolicy", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The resiliency policy for compute nodes in the pool."""
@overload
def __init__(
@@ -5470,6 +6024,146 @@ def __init__(
os_disk: Optional["_models.OSDisk"] = None,
security_profile: Optional["_models.SecurityProfile"] = None,
service_artifact_reference: Optional["_models.ServiceArtifactReference"] = None,
+ hardware_profile: Optional["_models.HardwareProfile"] = None,
+ placement: Optional["_models.Placement"] = None,
+ resiliency_policy: Optional["_models.ResiliencyPolicy"] = 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 VirtualMachineConfigurationPatch(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """Virtual machine settings retaining legacy requirements when updating zone policies.
+
+ :ivar image_reference: A reference to the Azure Virtual Machines Marketplace Image or the
+ custom Virtual Machine Image to use. Required.
+ :vartype image_reference: ~azure.mgmt.batch.models.ImageReference
+ :ivar node_agent_sku_id: The SKU of the Batch node agent to be provisioned on compute nodes in
+ the pool. Required.
+ :vartype node_agent_sku_id: str
+ :ivar windows_configuration: Windows operating system settings on the virtual machine.
+ :vartype windows_configuration: ~azure.mgmt.batch.models.WindowsConfiguration
+ :ivar data_disks: The configuration for data disks attached to the compute nodes in the pool.
+ :vartype data_disks: list[~azure.mgmt.batch.models.DataDisk]
+ :ivar license_type: The type of on-premises license to be used when deploying the operating
+ system.
+ :vartype license_type: str
+ :ivar container_configuration: The container configuration for the pool.
+ :vartype container_configuration: ~azure.mgmt.batch.models.ContainerConfiguration
+ :ivar disk_encryption_configuration: The disk encryption configuration for the pool.
+ :vartype disk_encryption_configuration: ~azure.mgmt.batch.models.DiskEncryptionConfiguration
+ :ivar node_placement_configuration: The node placement configuration for the pool.
+ :vartype node_placement_configuration: ~azure.mgmt.batch.models.NodePlacementConfiguration
+ :ivar extensions: The virtual machine extension for the pool.
+ :vartype extensions: list[~azure.mgmt.batch.models.VMExtension]
+ :ivar os_disk: Settings for the operating system disk of the Virtual Machine.
+ :vartype os_disk: ~azure.mgmt.batch.models.OSDisk
+ :ivar security_profile: Specifies the security profile settings for the virtual machine or
+ virtual machine scale set.
+ :vartype security_profile: ~azure.mgmt.batch.models.SecurityProfile
+ :ivar service_artifact_reference: Specifies the service artifact reference id used to set same
+ image version for all virtual machines in the scale set when using 'latest' image version.
+ :vartype service_artifact_reference: ~azure.mgmt.batch.models.ServiceArtifactReference
+ :ivar hardware_profile: Specifies the hardware settings for the compute nodes.
+ :vartype hardware_profile: ~azure.mgmt.batch.models.HardwareProfile
+ :ivar placement: The availability zone placement policy to update. Omitted fields retain their
+ existing values.
+ :vartype placement: ~azure.mgmt.batch.models.PlacementPatch
+ :ivar resiliency_policy: The resiliency policy to update. Omitted fields retain their existing
+ values.
+ :vartype resiliency_policy: ~azure.mgmt.batch.models.ResiliencyPolicyPatch
+ """
+
+ image_reference: "_models.ImageReference" = rest_field(
+ name="imageReference", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """A reference to the Azure Virtual Machines Marketplace Image or the custom Virtual Machine Image
+ to use. Required."""
+ node_agent_sku_id: str = rest_field(
+ name="nodeAgentSkuId", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The SKU of the Batch node agent to be provisioned on compute nodes in the pool. Required."""
+ windows_configuration: Optional["_models.WindowsConfiguration"] = rest_field(
+ name="windowsConfiguration", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """Windows operating system settings on the virtual machine."""
+ data_disks: Optional[list["_models.DataDisk"]] = rest_field(
+ name="dataDisks", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The configuration for data disks attached to the compute nodes in the pool."""
+ license_type: Optional[str] = rest_field(
+ name="licenseType", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The type of on-premises license to be used when deploying the operating system."""
+ container_configuration: Optional["_models.ContainerConfiguration"] = rest_field(
+ name="containerConfiguration", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The container configuration for the pool."""
+ disk_encryption_configuration: Optional["_models.DiskEncryptionConfiguration"] = rest_field(
+ name="diskEncryptionConfiguration", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The disk encryption configuration for the pool."""
+ node_placement_configuration: Optional["_models.NodePlacementConfiguration"] = rest_field(
+ name="nodePlacementConfiguration", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The node placement configuration for the pool."""
+ extensions: Optional[list["_models.VMExtension"]] = rest_field(
+ visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The virtual machine extension for the pool."""
+ os_disk: Optional["_models.OSDisk"] = rest_field(
+ name="osDisk", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """Settings for the operating system disk of the Virtual Machine."""
+ security_profile: Optional["_models.SecurityProfile"] = rest_field(
+ name="securityProfile", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """Specifies the security profile settings for the virtual machine or virtual machine scale set."""
+ service_artifact_reference: Optional["_models.ServiceArtifactReference"] = rest_field(
+ name="serviceArtifactReference", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """Specifies the service artifact reference id used to set same image version for all virtual
+ machines in the scale set when using 'latest' image version."""
+ hardware_profile: Optional["_models.HardwareProfile"] = rest_field(
+ name="hardwareProfile", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """Specifies the hardware settings for the compute nodes."""
+ placement: Optional["_models.PlacementPatch"] = rest_field(
+ visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The availability zone placement policy to update. Omitted fields retain their existing values."""
+ resiliency_policy: Optional["_models.ResiliencyPolicyPatch"] = rest_field(
+ name="resiliencyPolicy", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The resiliency policy to update. Omitted fields retain their existing values."""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ image_reference: "_models.ImageReference",
+ node_agent_sku_id: str,
+ windows_configuration: Optional["_models.WindowsConfiguration"] = None,
+ data_disks: Optional[list["_models.DataDisk"]] = None,
+ license_type: Optional[str] = None,
+ container_configuration: Optional["_models.ContainerConfiguration"] = None,
+ disk_encryption_configuration: Optional["_models.DiskEncryptionConfiguration"] = None,
+ node_placement_configuration: Optional["_models.NodePlacementConfiguration"] = None,
+ extensions: Optional[list["_models.VMExtension"]] = None,
+ os_disk: Optional["_models.OSDisk"] = None,
+ security_profile: Optional["_models.SecurityProfile"] = None,
+ service_artifact_reference: Optional["_models.ServiceArtifactReference"] = None,
+ hardware_profile: Optional["_models.HardwareProfile"] = None,
+ placement: Optional["_models.PlacementPatch"] = None,
+ resiliency_policy: Optional["_models.ResiliencyPolicyPatch"] = None,
) -> None: ...
@overload
@@ -5498,7 +6192,92 @@ class VirtualMachineFamilyCoreQuota(_Model):
"""The core quota for the VM family for the Batch account."""
-class VMDiskSecurityProfile(_Model):
+class VirtualMachineSkuProfile(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """Specifies the set of VM sizes and the allocation strategy used to allocate compute nodes for an
+ Instance Mix pool.
+
+ :ivar vm_sizes: The list of VM sizes (up to 5) that may be allocated for the Pool. VM sizes may
+ span the supported A, B, D, E, and F VM families, but must have the same vCPU count and CPU
+ architecture and compatible VM capabilities. This must be specified when the vmSkuProfile is
+ provided during Pool creation.
+ :vartype vm_sizes: list[~azure.mgmt.batch.models.VirtualMachineSkuProfileVmSize]
+ :ivar allocation_strategy: The allocation strategy used to select VM sizes from vmSizes.
+ Defaults to LowestPrice when not specified. Known values are: "LowestPrice",
+ "CapacityOptimized", and "Prioritized".
+ :vartype allocation_strategy: str or
+ ~azure.mgmt.batch.models.VirtualMachineSkuAllocationStrategy
+ """
+
+ vm_sizes: Optional[list["_models.VirtualMachineSkuProfileVmSize"]] = rest_field(
+ name="vmSizes", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The list of VM sizes (up to 5) that may be allocated for the Pool. VM sizes may span the
+ supported A, B, D, E, and F VM families, but must have the same vCPU count and CPU architecture
+ and compatible VM capabilities. This must be specified when the vmSkuProfile is provided during
+ Pool creation."""
+ allocation_strategy: Optional[Union[str, "_models.VirtualMachineSkuAllocationStrategy"]] = rest_field(
+ name="allocationStrategy", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The allocation strategy used to select VM sizes from vmSizes. Defaults to LowestPrice when not
+ specified. Known values are: \"LowestPrice\", \"CapacityOptimized\", and \"Prioritized\"."""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ vm_sizes: Optional[list["_models.VirtualMachineSkuProfileVmSize"]] = None,
+ allocation_strategy: Optional[Union[str, "_models.VirtualMachineSkuAllocationStrategy"]] = 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 VirtualMachineSkuProfileVmSize(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """Specifies a single VM size that may be allocated for an Instance Mix pool.
+
+ :ivar name: The name of the VM size (for example, "Standard_D8s_v5"). Required.
+ :vartype name: str
+ :ivar rank: The 0-based rank (a.k.a. priority) associated with this VM size. Lower values
+ indicate higher priority. Rank is required only when the allocation strategy is 'Prioritized'
+ and must be omitted otherwise.
+ :vartype rank: int
+ """
+
+ name: str = rest_field(visibility=["read", "create", "update", "delete", "query"])
+ """The name of the VM size (for example, \"Standard_D8s_v5\"). Required."""
+ rank: Optional[int] = rest_field(visibility=["read", "create", "update", "delete", "query"])
+ """The 0-based rank (a.k.a. priority) associated with this VM size. Lower values indicate higher
+ priority. Rank is required only when the allocation strategy is 'Prioritized' and must be
+ omitted otherwise."""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ name: str,
+ rank: 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 VMDiskSecurityProfile(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Specifies the security profile settings for the managed disk. **Note**: It can only be set for
Confidential VMs and is required when using Confidential VMs.
@@ -5548,7 +6327,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class VMExtension(_Model):
+class VMExtension(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""The configuration for virtual machine extensions.
:ivar name: The name of the virtual machine extension. Required.
@@ -5634,7 +6413,52 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class WindowsConfiguration(_Model):
+class VmSizeProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """Specifies the properties for customizing the size of the virtual machine.
+
+ :ivar v_cpus_available: Specifies the number of vCPUs available for the VM. When this property
+ is not specified in the request body the default behavior is to set it to the value of vCPUs
+ available for that VM size.
+ :vartype v_cpus_available: int
+ :ivar v_cpus_per_core: Specifies the vCPU to physical core ratio. When this property is not
+ specified in the request body the default behavior is set to the value of vCPUsPerCore for the
+ VM Size. **Setting this property to 1 also means that hyper-threading is disabled.**.
+ :vartype v_cpus_per_core: int
+ """
+
+ v_cpus_available: Optional[int] = rest_field(
+ name="vCPUsAvailable", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """Specifies the number of vCPUs available for the VM. When this property is not specified in the
+ request body the default behavior is to set it to the value of vCPUs available for that VM
+ size."""
+ v_cpus_per_core: Optional[int] = rest_field(
+ name="vCPUsPerCore", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """Specifies the vCPU to physical core ratio. When this property is not specified in the request
+ body the default behavior is set to the value of vCPUsPerCore for the VM Size. **Setting this
+ property to 1 also means that hyper-threading is disabled.**."""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ v_cpus_available: Optional[int] = None,
+ v_cpus_per_core: 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 WindowsConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Windows operating system settings to apply to the virtual machine.
:ivar enable_automatic_updates: Whether automatic updates are enabled on the virtual machine.
@@ -5664,7 +6488,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
-class WindowsUserConfiguration(_Model):
+class WindowsUserConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
"""Properties used to create a user account on a Windows node.
:ivar login_mode: Login mode for user. Known values are: "Batch" and "Interactive".
@@ -5692,3 +6516,86 @@ def __init__(self, mapping: Mapping[str, Any]) -> None:
def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
+
+
+class ZoneAllocationPolicy(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """The policy that controls allocation across availability zones.
+
+ :ivar max_zone_count: The maximum number of availability zones that may be used. The value
+ cannot exceed the number of zones supported by the region.
+ :vartype max_zone_count: int
+ :ivar max_instance_percent_per_zone_policy: The policy that limits the percentage of pool
+ instances that may be allocated in a single availability zone.
+ :vartype max_instance_percent_per_zone_policy:
+ ~azure.mgmt.batch.models.MaxInstancePercentPerZonePolicy
+ """
+
+ max_zone_count: Optional[int] = rest_field(
+ name="maxZoneCount", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The maximum number of availability zones that may be used. The value cannot exceed the number
+ of zones supported by the region."""
+ max_instance_percent_per_zone_policy: Optional["_models.MaxInstancePercentPerZonePolicy"] = rest_field(
+ name="maxInstancePercentPerZonePolicy", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The policy that limits the percentage of pool instances that may be allocated in a single
+ availability zone."""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ max_zone_count: Optional[int] = None,
+ max_instance_percent_per_zone_policy: Optional["_models.MaxInstancePercentPerZonePolicy"] = 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 ZoneAllocationPolicyPatch(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only
+ """Zone allocation policy fields to update, leaving omitted fields unchanged.
+
+ :ivar max_zone_count: The maximum number of availability zones that may be used. The value
+ cannot exceed the number of zones supported by the region.
+ :vartype max_zone_count: int
+ :ivar max_instance_percent_per_zone_policy: The per-zone instance percentage policy fields to
+ update.
+ :vartype max_instance_percent_per_zone_policy:
+ ~azure.mgmt.batch.models.MaxInstancePercentPerZonePolicyPatch
+ """
+
+ max_zone_count: Optional[int] = rest_field(
+ name="maxZoneCount", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The maximum number of availability zones that may be used. The value cannot exceed the number
+ of zones supported by the region."""
+ max_instance_percent_per_zone_policy: Optional["_models.MaxInstancePercentPerZonePolicyPatch"] = rest_field(
+ name="maxInstancePercentPerZonePolicy", visibility=["read", "create", "update", "delete", "query"]
+ )
+ """The per-zone instance percentage policy fields to update."""
+
+ @overload
+ def __init__(
+ self,
+ *,
+ max_zone_count: Optional[int] = None,
+ max_instance_percent_per_zone_policy: Optional["_models.MaxInstancePercentPerZonePolicyPatch"] = 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)
diff --git a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/models/_patch.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/models/_patch.py
index 87676c65a8f0..ea765788358a 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/models/_patch.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/models/_patch.py
@@ -8,7 +8,6 @@
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/batch/azure-mgmt-batch/azure/mgmt/batch/operations/_operations.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/operations/_operations.py
index 30248b0046b2..a377799021aa 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/operations/_operations.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/operations/_operations.py
@@ -33,7 +33,7 @@
from azure.mgmt.core.exceptions import ARMErrorFormat
from azure.mgmt.core.polling.arm_polling import ARMPolling
-from .. import models as _models
+from .. import models as _models, types as _types
from .._configuration import BatchManagementClientConfiguration
from .._utils.model_base import SdkJSONEncoder, _deserialize, _failsafe_deserialize
from .._utils.serialization import Deserializer, Serializer
@@ -41,7 +41,6 @@
T = TypeVar("T")
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, dict[str, Any]], Any]]
-JSON = MutableMapping[str, Any]
List = list
_SERIALIZER = Serializer()
@@ -52,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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -73,7 +72,7 @@ def build_batch_account_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -102,7 +101,7 @@ def build_batch_account_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -133,7 +132,7 @@ def build_batch_account_update_request(
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
- api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -162,7 +161,7 @@ def build_batch_account_delete_request(
) -> HttpRequest:
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
# Construct URL
_url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}"
path_format_arguments = {
@@ -185,7 +184,7 @@ def build_batch_account_list_by_resource_group_request( # pylint: disable=name-
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -210,7 +209,7 @@ def build_batch_account_list_request(subscription_id: str, **kwargs: Any) -> Htt
_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -235,7 +234,7 @@ def build_batch_account_synchronize_auto_storage_keys_request( # pylint: disabl
) -> HttpRequest:
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
# Construct URL
_url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/syncAutoStorageKeys"
path_format_arguments = {
@@ -259,7 +258,7 @@ def build_batch_account_regenerate_key_request( # pylint: disable=name-too-long
_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -289,7 +288,7 @@ def build_batch_account_get_keys_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -317,7 +316,7 @@ def build_batch_account_list_outbound_network_dependencies_endpoints_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -345,7 +344,7 @@ def build_batch_account_get_detector_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -374,7 +373,7 @@ def build_batch_account_list_detectors_request( # pylint: disable=name-too-long
_headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -407,7 +406,7 @@ def build_application_package_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -443,7 +442,7 @@ def build_application_package_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -479,7 +478,7 @@ def build_application_package_delete_request(
) -> HttpRequest:
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
# Construct URL
_url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/applications/{applicationName}/versions/{versionName}"
path_format_arguments = {
@@ -510,7 +509,7 @@ def build_application_package_list_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -547,7 +546,7 @@ def build_application_package_activate_request( # pylint: disable=name-too-long
_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -579,7 +578,7 @@ def build_application_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -609,7 +608,7 @@ def build_application_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -641,7 +640,7 @@ def build_application_update_request(
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
- api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -671,7 +670,7 @@ def build_application_delete_request(
) -> HttpRequest:
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
# Construct URL
_url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/applications/{applicationName}"
path_format_arguments = {
@@ -700,7 +699,7 @@ def build_application_list_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -730,7 +729,7 @@ def build_private_link_resource_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -764,7 +763,7 @@ def build_private_link_resource_list_by_batch_account_request( # pylint: disabl
_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -798,7 +797,7 @@ def build_private_endpoint_connection_get_request( # pylint: disable=name-too-l
_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -837,7 +836,7 @@ def build_private_endpoint_connection_update_request( # pylint: disable=name-to
_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -865,7 +864,7 @@ def build_private_endpoint_connection_update_request( # pylint: disable=name-to
_headers["If-Match"] = _SERIALIZER.header("if_match", if_match, "str")
if_none_match = prep_if_none_match(etag, match_condition)
if if_none_match is not None:
- _headers["If-None-Match"] = _SERIALIZER.header("if_none_match", if_none_match, "str")
+ _headers["if-none-match"] = _SERIALIZER.header("if_none_match", if_none_match, "str")
return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs)
@@ -879,7 +878,7 @@ def build_private_endpoint_connection_delete_request( # pylint: disable=name-to
) -> HttpRequest:
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
# Construct URL
_url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/privateEndpointConnections/{privateEndpointConnectionName}"
path_format_arguments = {
@@ -910,7 +909,7 @@ def build_private_endpoint_connection_list_by_batch_account_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -940,7 +939,7 @@ def build_pool_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -977,7 +976,7 @@ def build_pool_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -1022,7 +1021,7 @@ def build_pool_update_request(
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
- api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -1048,7 +1047,7 @@ def build_pool_update_request(
_headers["If-Match"] = _SERIALIZER.header("if_match", if_match, "str")
if_none_match = prep_if_none_match(etag, match_condition)
if if_none_match is not None:
- _headers["If-None-Match"] = _SERIALIZER.header("if_none_match", if_none_match, "str")
+ _headers["if-none-match"] = _SERIALIZER.header("if_none_match", if_none_match, "str")
return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs)
@@ -1058,7 +1057,7 @@ def build_pool_delete_request(
) -> HttpRequest:
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
# Construct URL
_url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/pools/{poolName}"
path_format_arguments = {
@@ -1089,7 +1088,7 @@ def build_pool_list_by_batch_account_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -1123,7 +1122,7 @@ def build_pool_disable_auto_scale_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -1152,7 +1151,7 @@ def build_pool_stop_resize_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -1185,7 +1184,7 @@ def build_network_security_perimeter_get_configuration_request( # pylint: disab
_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -1216,7 +1215,7 @@ def build_network_security_perimeter_list_configurations_request( # pylint: dis
_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -1247,7 +1246,7 @@ def build_network_security_perimeter_reconcile_configuration_request( # pylint:
) -> HttpRequest:
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
- api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
# Construct URL
_url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/networkSecurityPerimeterConfigurations/{networkSecurityPerimeterConfigurationName}/reconcile"
path_format_arguments = {
@@ -1271,7 +1270,7 @@ def build_location_get_quotas_request(location_name: str, subscription_id: str,
_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -1303,7 +1302,7 @@ def build_location_list_supported_virtual_machine_skus_request( # pylint: disab
_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", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -1335,7 +1334,7 @@ def build_location_check_name_availability_request( # pylint: disable=name-too-
_params = case_insensitive_dict(kwargs.pop("params", {}) or {})
content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
- api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2025-06-01"))
+ api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-10-01"))
accept = _headers.pop("Accept", "application/json")
# Construct URL
@@ -1358,7 +1357,7 @@ def build_location_check_name_availability_request( # pylint: disable=name-too-
return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
-class Operations:
+class Operations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -1422,7 +1421,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -1435,7 +1437,10 @@ def prepare_request(next_link=None):
def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.Operation], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.Operation],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, iter(list_of_elem)
@@ -1462,7 +1467,7 @@ def get_next(next_link=None):
return ItemPaged(get_next, extract_data)
-class BatchAccountOperations:
+class BatchAccountOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -1523,6 +1528,7 @@ def get(self, resource_group_name: str, account_name: str, **kwargs: Any) -> _mo
}
_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
@@ -1544,7 +1550,7 @@ def get(self, resource_group_name: str, account_name: str, **kwargs: Any) -> _mo
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.BatchAccount, response.json())
@@ -1557,7 +1563,7 @@ def _create_initial(
self,
resource_group_name: str,
account_name: str,
- parameters: Union[_models.BatchAccountCreateParameters, JSON, IO[bytes]],
+ parameters: Union[_models.BatchAccountCreateParameters, _types.BatchAccountCreateParameters, IO[bytes]],
**kwargs: Any
) -> Iterator[bytes]:
error_map: MutableMapping = {
@@ -1596,6 +1602,7 @@ def _create_initial(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = True
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -1620,7 +1627,7 @@ def _create_initial(
response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
if cls:
return cls(pipeline_response, deserialized, response_headers) # type: ignore
@@ -1666,7 +1673,7 @@ def begin_create(
self,
resource_group_name: str,
account_name: str,
- parameters: JSON,
+ parameters: _types.BatchAccountCreateParameters,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -1685,7 +1692,7 @@ def begin_create(
Required.
:type account_name: str
:param parameters: Additional parameters for account creation. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.BatchAccountCreateParameters
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -1734,7 +1741,7 @@ def begin_create(
self,
resource_group_name: str,
account_name: str,
- parameters: Union[_models.BatchAccountCreateParameters, JSON, IO[bytes]],
+ parameters: Union[_models.BatchAccountCreateParameters, _types.BatchAccountCreateParameters, IO[bytes]],
**kwargs: Any
) -> LROPoller[_models.BatchAccount]:
"""Creates a new Batch account with the specified parameters. Existing accounts cannot be updated
@@ -1750,9 +1757,10 @@ def begin_create(
`http://accountname.region.batch.azure.com/ `_.
Required.
:type account_name: str
- :param parameters: Additional parameters for account creation. Is one of the following types:
- BatchAccountCreateParameters, JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.BatchAccountCreateParameters or JSON or IO[bytes]
+ :param parameters: Additional parameters for account creation. Is either a
+ BatchAccountCreateParameters type or a IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.batch.models.BatchAccountCreateParameters or
+ ~azure.mgmt.batch.types.BatchAccountCreateParameters or IO[bytes]
:return: An instance of LROPoller that returns BatchAccount. The BatchAccount is compatible
with MutableMapping
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.batch.models.BatchAccount]
@@ -1847,7 +1855,7 @@ def update(
self,
resource_group_name: str,
account_name: str,
- parameters: JSON,
+ parameters: _types.BatchAccountUpdateParameters,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -1865,7 +1873,7 @@ def update(
Required.
:type account_name: str
:param parameters: Additional parameters for account update. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.BatchAccountUpdateParameters
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -1911,7 +1919,7 @@ def update(
self,
resource_group_name: str,
account_name: str,
- parameters: Union[_models.BatchAccountUpdateParameters, JSON, IO[bytes]],
+ parameters: Union[_models.BatchAccountUpdateParameters, _types.BatchAccountUpdateParameters, IO[bytes]],
**kwargs: Any
) -> _models.BatchAccount:
"""Updates the properties of an existing Batch account.
@@ -1926,9 +1934,10 @@ def update(
`http://accountname.region.batch.azure.com/ `_.
Required.
:type account_name: str
- :param parameters: Additional parameters for account update. Is one of the following types:
- BatchAccountUpdateParameters, JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.BatchAccountUpdateParameters or JSON or IO[bytes]
+ :param parameters: Additional parameters for account update. Is either a
+ BatchAccountUpdateParameters type or a IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.batch.models.BatchAccountUpdateParameters or
+ ~azure.mgmt.batch.types.BatchAccountUpdateParameters or IO[bytes]
:return: BatchAccount. The BatchAccount is compatible with MutableMapping
:rtype: ~azure.mgmt.batch.models.BatchAccount
:raises ~azure.core.exceptions.HttpResponseError:
@@ -1969,6 +1978,7 @@ def update(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = kwargs.pop("stream", False)
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -1990,7 +2000,7 @@ def update(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.BatchAccount, response.json())
@@ -2026,6 +2036,7 @@ def _delete_initial(self, resource_group_name: str, account_name: str, **kwargs:
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = True
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -2050,7 +2061,7 @@ def _delete_initial(self, resource_group_name: str, account_name: str, **kwargs:
response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
if cls:
return cls(pipeline_response, deserialized, response_headers) # type: ignore
@@ -2171,7 +2182,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -2184,7 +2198,10 @@ def prepare_request(next_link=None):
def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.BatchAccount], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.BatchAccount],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, iter(list_of_elem)
@@ -2258,7 +2275,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -2271,7 +2291,10 @@ def prepare_request(next_link=None):
def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.BatchAccount], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.BatchAccount],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, iter(list_of_elem)
@@ -2404,7 +2427,7 @@ def regenerate_key(
self,
resource_group_name: str,
account_name: str,
- parameters: JSON,
+ parameters: _types.BatchAccountRegenerateKeyParameters,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -2427,7 +2450,7 @@ def regenerate_key(
Required.
:type account_name: str
:param parameters: The type of key to regenerate. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.BatchAccountRegenerateKeyParameters
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -2478,7 +2501,9 @@ def regenerate_key(
self,
resource_group_name: str,
account_name: str,
- parameters: Union[_models.BatchAccountRegenerateKeyParameters, JSON, IO[bytes]],
+ parameters: Union[
+ _models.BatchAccountRegenerateKeyParameters, _types.BatchAccountRegenerateKeyParameters, IO[bytes]
+ ],
**kwargs: Any
) -> _models.BatchAccountKeys:
"""Regenerates the specified account key for the Batch account.
@@ -2498,10 +2523,10 @@ def regenerate_key(
`http://accountname.region.batch.azure.com/ `_.
Required.
:type account_name: str
- :param parameters: The type of key to regenerate. Is one of the following types:
- BatchAccountRegenerateKeyParameters, JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.BatchAccountRegenerateKeyParameters or JSON or
- IO[bytes]
+ :param parameters: The type of key to regenerate. Is either a
+ BatchAccountRegenerateKeyParameters type or a IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.batch.models.BatchAccountRegenerateKeyParameters or
+ ~azure.mgmt.batch.types.BatchAccountRegenerateKeyParameters or IO[bytes]
:return: BatchAccountKeys. The BatchAccountKeys is compatible with MutableMapping
:rtype: ~azure.mgmt.batch.models.BatchAccountKeys
:raises ~azure.core.exceptions.HttpResponseError:
@@ -2542,6 +2567,7 @@ def regenerate_key(
}
_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
@@ -2563,7 +2589,7 @@ def regenerate_key(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.BatchAccountKeys, response.json())
@@ -2621,6 +2647,7 @@ def get_keys(self, resource_group_name: str, account_name: str, **kwargs: Any) -
}
_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
@@ -2642,7 +2669,7 @@ def get_keys(self, resource_group_name: str, account_name: str, **kwargs: Any) -
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.BatchAccountKeys, response.json())
@@ -2719,7 +2746,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -2732,7 +2762,10 @@ def prepare_request(next_link=None):
def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.OutboundEnvironmentEndpoint], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.OutboundEnvironmentEndpoint],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, iter(list_of_elem)
@@ -2807,6 +2840,7 @@ def get_detector(
}
_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
@@ -2828,7 +2862,7 @@ def get_detector(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.DetectorResponse, response.json())
@@ -2899,7 +2933,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -2912,7 +2949,10 @@ def prepare_request(next_link=None):
def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.DetectorResponse], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.DetectorResponse],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, iter(list_of_elem)
@@ -2939,7 +2979,7 @@ def get_next(next_link=None):
return ItemPaged(get_next, extract_data)
-class ApplicationPackageOperations:
+class ApplicationPackageOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -3009,6 +3049,7 @@ def get(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = kwargs.pop("stream", False)
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -3030,7 +3071,7 @@ def get(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.ApplicationPackage, response.json())
@@ -3088,7 +3129,7 @@ def create(
account_name: str,
application_name: str,
version_name: str,
- parameters: Optional[JSON] = None,
+ parameters: Optional[_types.ApplicationPackage] = None,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -3114,7 +3155,7 @@ def create(
:param version_name: The version of the application. Required.
:type version_name: str
:param parameters: The parameters for the request. Default value is None.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.ApplicationPackage
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -3172,7 +3213,7 @@ def create(
account_name: str,
application_name: str,
version_name: str,
- parameters: Optional[Union[_models.ApplicationPackage, JSON, IO[bytes]]] = None,
+ parameters: Optional[Union[_models.ApplicationPackage, _types.ApplicationPackage, IO[bytes]]] = None,
**kwargs: Any
) -> _models.ApplicationPackage:
"""Creates an application package record. The record contains a storageUrl where the package
@@ -3195,9 +3236,10 @@ def create(
:type application_name: str
:param version_name: The version of the application. Required.
:type version_name: str
- :param parameters: The parameters for the request. Is one of the following types:
- ApplicationPackage, JSON, IO[bytes] Default value is None.
- :type parameters: ~azure.mgmt.batch.models.ApplicationPackage or JSON or IO[bytes]
+ :param parameters: The parameters for the request. Is either a ApplicationPackage type or a
+ IO[bytes] type. Default value is None.
+ :type parameters: ~azure.mgmt.batch.models.ApplicationPackage or
+ ~azure.mgmt.batch.types.ApplicationPackage or IO[bytes]
:return: ApplicationPackage. The ApplicationPackage is compatible with MutableMapping
:rtype: ~azure.mgmt.batch.models.ApplicationPackage
:raises ~azure.core.exceptions.HttpResponseError:
@@ -3244,6 +3286,7 @@ def create(
}
_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
@@ -3265,7 +3308,7 @@ def create(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.ApplicationPackage, response.json())
@@ -3421,7 +3464,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -3434,7 +3480,10 @@ def prepare_request(next_link=None):
def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.ApplicationPackage], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.ApplicationPackage],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, iter(list_of_elem)
@@ -3508,7 +3557,7 @@ def activate(
account_name: str,
application_name: str,
version_name: str,
- parameters: JSON,
+ parameters: _types.ActivateApplicationPackageParameters,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -3533,7 +3582,7 @@ def activate(
:param version_name: The version of the application. Required.
:type version_name: str
:param parameters: The parameters for the request. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.ActivateApplicationPackageParameters
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -3590,7 +3639,9 @@ def activate(
account_name: str,
application_name: str,
version_name: str,
- parameters: Union[_models.ActivateApplicationPackageParameters, JSON, IO[bytes]],
+ parameters: Union[
+ _models.ActivateApplicationPackageParameters, _types.ActivateApplicationPackageParameters, IO[bytes]
+ ],
**kwargs: Any
) -> _models.ApplicationPackage:
"""Activates the specified application package. This should be done after the
@@ -3612,10 +3663,10 @@ def activate(
:type application_name: str
:param version_name: The version of the application. Required.
:type version_name: str
- :param parameters: The parameters for the request. Is one of the following types:
- ActivateApplicationPackageParameters, JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.ActivateApplicationPackageParameters or JSON or
- IO[bytes]
+ :param parameters: The parameters for the request. Is either a
+ ActivateApplicationPackageParameters type or a IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.batch.models.ActivateApplicationPackageParameters or
+ ~azure.mgmt.batch.types.ActivateApplicationPackageParameters or IO[bytes]
:return: ApplicationPackage. The ApplicationPackage is compatible with MutableMapping
:rtype: ~azure.mgmt.batch.models.ApplicationPackage
:raises ~azure.core.exceptions.HttpResponseError:
@@ -3658,6 +3709,7 @@ def activate(
}
_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
@@ -3679,7 +3731,7 @@ def activate(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.ApplicationPackage, response.json())
@@ -3689,7 +3741,7 @@ def activate(
return deserialized # type: ignore
-class ApplicationOperations:
+class ApplicationOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -3756,6 +3808,7 @@ def get(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = kwargs.pop("stream", False)
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -3777,7 +3830,7 @@ def get(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Application, response.json())
@@ -3828,7 +3881,7 @@ def create(
resource_group_name: str,
account_name: str,
application_name: str,
- parameters: Optional[JSON] = None,
+ parameters: Optional[_types.Application] = None,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -3849,7 +3902,7 @@ def create(
Required.
:type application_name: str
:param parameters: The parameters for the request. Default value is None.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.Application
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -3900,7 +3953,7 @@ def create(
resource_group_name: str,
account_name: str,
application_name: str,
- parameters: Optional[Union[_models.Application, JSON, IO[bytes]]] = None,
+ parameters: Optional[Union[_models.Application, _types.Application, IO[bytes]]] = None,
**kwargs: Any
) -> _models.Application:
"""Adds an application to the specified Batch account.
@@ -3918,9 +3971,10 @@ def create(
:param application_name: The name of the application. This must be unique within the account.
Required.
:type application_name: str
- :param parameters: The parameters for the request. Is one of the following types: Application,
- JSON, IO[bytes] Default value is None.
- :type parameters: ~azure.mgmt.batch.models.Application or JSON or IO[bytes]
+ :param parameters: The parameters for the request. Is either a Application type or a IO[bytes]
+ type. Default value is None.
+ :type parameters: ~azure.mgmt.batch.models.Application or ~azure.mgmt.batch.types.Application
+ or IO[bytes]
:return: Application. The Application is compatible with MutableMapping
:rtype: ~azure.mgmt.batch.models.Application
:raises ~azure.core.exceptions.HttpResponseError:
@@ -3966,6 +4020,7 @@ def create(
}
_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
@@ -3987,7 +4042,7 @@ def create(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Application, response.json())
@@ -4038,7 +4093,7 @@ def update(
resource_group_name: str,
account_name: str,
application_name: str,
- parameters: JSON,
+ parameters: _types.Application,
*,
content_type: str = "application/json",
**kwargs: Any
@@ -4059,7 +4114,7 @@ def update(
Required.
:type application_name: str
:param parameters: The parameters for the request. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.Application
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -4110,7 +4165,7 @@ def update(
resource_group_name: str,
account_name: str,
application_name: str,
- parameters: Union[_models.Application, JSON, IO[bytes]],
+ parameters: Union[_models.Application, _types.Application, IO[bytes]],
**kwargs: Any
) -> _models.Application:
"""Updates settings for the specified application.
@@ -4128,9 +4183,10 @@ def update(
:param application_name: The name of the application. This must be unique within the account.
Required.
:type application_name: str
- :param parameters: The parameters for the request. Is one of the following types: Application,
- JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.Application or JSON or IO[bytes]
+ :param parameters: The parameters for the request. Is either a Application type or a IO[bytes]
+ type. Required.
+ :type parameters: ~azure.mgmt.batch.models.Application or ~azure.mgmt.batch.types.Application
+ or IO[bytes]
:return: Application. The Application is compatible with MutableMapping
:rtype: ~azure.mgmt.batch.models.Application
:raises ~azure.core.exceptions.HttpResponseError:
@@ -4172,6 +4228,7 @@ def update(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = kwargs.pop("stream", False)
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -4193,7 +4250,7 @@ def update(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Application, response.json())
@@ -4336,7 +4393,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -4349,7 +4409,10 @@ def prepare_request(next_link=None):
def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.Application], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.Application],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, iter(list_of_elem)
@@ -4376,7 +4439,7 @@ def get_next(next_link=None):
return ItemPaged(get_next, extract_data)
-class PrivateLinkResourceOperations:
+class PrivateLinkResourceOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -4443,6 +4506,7 @@ def get(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = kwargs.pop("stream", False)
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -4464,7 +4528,7 @@ def get(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.PrivateLinkResource, response.json())
@@ -4539,7 +4603,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -4552,7 +4619,10 @@ def prepare_request(next_link=None):
def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.PrivateLinkResource], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.PrivateLinkResource],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, iter(list_of_elem)
@@ -4579,7 +4649,7 @@ def get_next(next_link=None):
return ItemPaged(get_next, extract_data)
-class PrivateEndpointConnectionOperations:
+class PrivateEndpointConnectionOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -4647,6 +4717,7 @@ def get(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = kwargs.pop("stream", False)
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -4668,7 +4739,7 @@ def get(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.PrivateEndpointConnection, response.json())
@@ -4682,7 +4753,7 @@ def _update_initial(
resource_group_name: str,
account_name: str,
private_endpoint_connection_name: str,
- parameters: Union[_models.PrivateEndpointConnection, JSON, IO[bytes]],
+ parameters: Union[_models.PrivateEndpointConnection, _types.PrivateEndpointConnection, IO[bytes]],
*,
etag: Optional[str] = None,
match_condition: Optional[MatchConditions] = None,
@@ -4733,6 +4804,7 @@ def _update_initial(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = True
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -4760,7 +4832,7 @@ def _update_initial(
response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
if cls:
return cls(pipeline_response, deserialized, response_headers) # type: ignore
@@ -4818,7 +4890,7 @@ def begin_update(
resource_group_name: str,
account_name: str,
private_endpoint_connection_name: str,
- parameters: JSON,
+ parameters: _types.PrivateEndpointConnection,
*,
content_type: str = "application/json",
etag: Optional[str] = None,
@@ -4842,7 +4914,7 @@ def begin_update(
:type private_endpoint_connection_name: str
:param parameters: PrivateEndpointConnection properties that should be updated. Properties that
are supplied will be updated, any property not supplied will be unchanged. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.PrivateEndpointConnection
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -4908,7 +4980,7 @@ def begin_update(
resource_group_name: str,
account_name: str,
private_endpoint_connection_name: str,
- parameters: Union[_models.PrivateEndpointConnection, JSON, IO[bytes]],
+ parameters: Union[_models.PrivateEndpointConnection, _types.PrivateEndpointConnection, IO[bytes]],
*,
etag: Optional[str] = None,
match_condition: Optional[MatchConditions] = None,
@@ -4930,9 +5002,10 @@ def begin_update(
unique within the account. Required.
:type private_endpoint_connection_name: str
:param parameters: PrivateEndpointConnection properties that should be updated. Properties that
- are supplied will be updated, any property not supplied will be unchanged. Is one of the
- following types: PrivateEndpointConnection, JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.PrivateEndpointConnection or JSON or IO[bytes]
+ are supplied will be updated, any property not supplied will be unchanged. Is either a
+ PrivateEndpointConnection type or a IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.batch.models.PrivateEndpointConnection or
+ ~azure.mgmt.batch.types.PrivateEndpointConnection or IO[bytes]
:keyword etag: check if resource is changed. Set None to skip checking etag. Default value is
None.
:paramtype etag: str
@@ -5028,6 +5101,7 @@ def _delete_initial(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = True
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -5055,7 +5129,7 @@ def _delete_initial(
response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
if cls:
return cls(pipeline_response, deserialized, response_headers) # type: ignore
@@ -5196,7 +5270,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -5209,7 +5286,10 @@ def prepare_request(next_link=None):
def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.PrivateEndpointConnection], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.PrivateEndpointConnection],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, iter(list_of_elem)
@@ -5236,7 +5316,7 @@ def get_next(next_link=None):
return ItemPaged(get_next, extract_data)
-class PoolOperations:
+class PoolOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -5300,6 +5380,7 @@ def get(self, resource_group_name: str, account_name: str, pool_name: str, **kwa
}
_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
@@ -5324,7 +5405,7 @@ def get(self, resource_group_name: str, account_name: str, pool_name: str, **kwa
response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag"))
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Pool, response.json())
@@ -5381,7 +5462,7 @@ def create(
resource_group_name: str,
account_name: str,
pool_name: str,
- parameters: JSON,
+ parameters: _types.Pool,
*,
content_type: str = "application/json",
etag: Optional[str] = None,
@@ -5403,7 +5484,7 @@ def create(
:param pool_name: The pool name. This must be unique within the account. Required.
:type pool_name: str
:param parameters: Additional parameters for pool creation. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.Pool
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -5465,7 +5546,7 @@ def create(
resource_group_name: str,
account_name: str,
pool_name: str,
- parameters: Union[_models.Pool, JSON, IO[bytes]],
+ parameters: Union[_models.Pool, _types.Pool, IO[bytes]],
*,
etag: Optional[str] = None,
match_condition: Optional[MatchConditions] = None,
@@ -5485,9 +5566,9 @@ def create(
:type account_name: str
:param pool_name: The pool name. This must be unique within the account. Required.
:type pool_name: str
- :param parameters: Additional parameters for pool creation. Is one of the following types:
- Pool, JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.Pool or JSON or IO[bytes]
+ :param parameters: Additional parameters for pool creation. Is either a Pool type or a
+ IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.batch.models.Pool or ~azure.mgmt.batch.types.Pool or IO[bytes]
:keyword etag: check if resource is changed. Set None to skip checking etag. Default value is
None.
:paramtype etag: str
@@ -5542,6 +5623,7 @@ def create(
}
_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
@@ -5566,7 +5648,7 @@ def create(
response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag"))
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Pool, response.json())
@@ -5581,7 +5663,7 @@ def update(
resource_group_name: str,
account_name: str,
pool_name: str,
- parameters: _models.Pool,
+ parameters: _models.PoolPatch,
*,
content_type: str = "application/json",
etag: Optional[str] = None,
@@ -5604,7 +5686,7 @@ def update(
:type pool_name: str
:param parameters: Pool properties that should be updated. Properties that are supplied will be
updated, any property not supplied will be unchanged. Required.
- :type parameters: ~azure.mgmt.batch.models.Pool
+ :type parameters: ~azure.mgmt.batch.models.PoolPatch
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -5624,7 +5706,7 @@ def update(
resource_group_name: str,
account_name: str,
pool_name: str,
- parameters: JSON,
+ parameters: _types.PoolPatch,
*,
content_type: str = "application/json",
etag: Optional[str] = None,
@@ -5647,7 +5729,7 @@ def update(
:type pool_name: str
:param parameters: Pool properties that should be updated. Properties that are supplied will be
updated, any property not supplied will be unchanged. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.PoolPatch
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -5710,7 +5792,7 @@ def update(
resource_group_name: str,
account_name: str,
pool_name: str,
- parameters: Union[_models.Pool, JSON, IO[bytes]],
+ parameters: Union[_models.PoolPatch, _types.PoolPatch, IO[bytes]],
*,
etag: Optional[str] = None,
match_condition: Optional[MatchConditions] = None,
@@ -5731,9 +5813,10 @@ def update(
:param pool_name: The pool name. This must be unique within the account. Required.
:type pool_name: str
:param parameters: Pool properties that should be updated. Properties that are supplied will be
- updated, any property not supplied will be unchanged. Is one of the following types: Pool,
- JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.Pool or JSON or IO[bytes]
+ updated, any property not supplied will be unchanged. Is either a PoolPatch type or a IO[bytes]
+ type. Required.
+ :type parameters: ~azure.mgmt.batch.models.PoolPatch or ~azure.mgmt.batch.types.PoolPatch or
+ IO[bytes]
:keyword etag: check if resource is changed. Set None to skip checking etag. Default value is
None.
:paramtype etag: str
@@ -5788,6 +5871,7 @@ def update(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = kwargs.pop("stream", False)
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -5812,7 +5896,7 @@ def update(
response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag"))
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Pool, response.json())
@@ -5851,6 +5935,7 @@ def _delete_initial(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = True
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -5875,7 +5960,7 @@ def _delete_initial(
response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
if cls:
return cls(pipeline_response, deserialized, response_headers) # type: ignore
@@ -6042,7 +6127,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -6055,7 +6143,10 @@ def prepare_request(next_link=None):
def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.Pool], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.Pool],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, iter(list_of_elem)
@@ -6130,6 +6221,7 @@ def disable_auto_scale(
}
_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
@@ -6154,7 +6246,7 @@ def disable_auto_scale(
response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag"))
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Pool, response.json())
@@ -6217,6 +6309,7 @@ def stop_resize(self, resource_group_name: str, account_name: str, pool_name: st
}
_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
@@ -6241,7 +6334,7 @@ def stop_resize(self, resource_group_name: str, account_name: str, pool_name: st
response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag"))
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.Pool, response.json())
@@ -6251,7 +6344,7 @@ def stop_resize(self, resource_group_name: str, account_name: str, pool_name: st
return deserialized # type: ignore
-class NetworkSecurityPerimeterOperations:
+class NetworkSecurityPerimeterOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -6323,6 +6416,7 @@ def get_configuration(
}
_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
@@ -6344,7 +6438,7 @@ def get_configuration(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.NetworkSecurityPerimeterConfiguration, response.json())
@@ -6416,7 +6510,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -6430,7 +6527,8 @@ def prepare_request(next_link=None):
def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
list_of_elem = _deserialize(
- List[_models.NetworkSecurityPerimeterConfiguration], deserialized.get("value", [])
+ List[_models.NetworkSecurityPerimeterConfiguration],
+ deserialized.get("value", []),
)
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
@@ -6491,6 +6589,7 @@ def _reconcile_configuration_initial(
}
_request.url = self._client.format_url(_request.url, **path_format_arguments)
+ _decompress = kwargs.pop("decompress", True)
_stream = True
pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
_request, stream=_stream, **kwargs
@@ -6514,7 +6613,7 @@ def _reconcile_configuration_initial(
response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
if cls:
return cls(pipeline_response, deserialized, response_headers) # type: ignore
@@ -6594,7 +6693,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-
return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore
-class LocationOperations:
+class LocationOperations: # pylint: disable=docstring-missing-param
"""
.. warning::
**DO NOT** instantiate this class directly.
@@ -6646,6 +6745,7 @@ def get_quotas(self, location_name: str, **kwargs: Any) -> _models.BatchLocation
}
_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
@@ -6667,7 +6767,7 @@ def get_quotas(self, location_name: str, **kwargs: Any) -> _models.BatchLocation
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.BatchLocationQuota, response.json())
@@ -6737,7 +6837,10 @@ def prepare_request(next_link=None):
)
_next_request_params["api-version"] = self._config.api_version
_request = HttpRequest(
- "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
+ "GET",
+ urllib.parse.urljoin(next_link, _parsed_next_link.path),
+ headers=_headers,
+ params=_next_request_params,
)
path_format_arguments = {
"endpoint": self._serialize.url(
@@ -6750,7 +6853,10 @@ def prepare_request(next_link=None):
def extract_data(pipeline_response):
deserialized = pipeline_response.http_response.json()
- list_of_elem = _deserialize(List[_models.SupportedSku], deserialized.get("value", []))
+ list_of_elem = _deserialize(
+ List[_models.SupportedSku],
+ deserialized.get("value", []),
+ )
if cls:
list_of_elem = cls(list_of_elem) # type: ignore
return deserialized.get("nextLink") or None, iter(list_of_elem)
@@ -6802,14 +6908,19 @@ def check_name_availability(
@overload
def check_name_availability(
- self, location_name: str, parameters: JSON, *, content_type: str = "application/json", **kwargs: Any
+ self,
+ location_name: str,
+ parameters: _types.CheckNameAvailabilityParameters,
+ *,
+ content_type: str = "application/json",
+ **kwargs: Any
) -> _models.CheckNameAvailabilityResult:
"""Checks whether the Batch account name is available in the specified region.
:param location_name: The desired region for the name check. Required.
:type location_name: str
:param parameters: Properties needed to check the availability of a name. Required.
- :type parameters: JSON
+ :type parameters: ~azure.mgmt.batch.types.CheckNameAvailabilityParameters
:keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
Default value is "application/json".
:paramtype content_type: str
@@ -6842,16 +6953,17 @@ def check_name_availability(
def check_name_availability(
self,
location_name: str,
- parameters: Union[_models.CheckNameAvailabilityParameters, JSON, IO[bytes]],
+ parameters: Union[_models.CheckNameAvailabilityParameters, _types.CheckNameAvailabilityParameters, IO[bytes]],
**kwargs: Any
) -> _models.CheckNameAvailabilityResult:
"""Checks whether the Batch account name is available in the specified region.
:param location_name: The desired region for the name check. Required.
:type location_name: str
- :param parameters: Properties needed to check the availability of a name. Is one of the
- following types: CheckNameAvailabilityParameters, JSON, IO[bytes] Required.
- :type parameters: ~azure.mgmt.batch.models.CheckNameAvailabilityParameters or JSON or IO[bytes]
+ :param parameters: Properties needed to check the availability of a name. Is either a
+ CheckNameAvailabilityParameters type or a IO[bytes] type. Required.
+ :type parameters: ~azure.mgmt.batch.models.CheckNameAvailabilityParameters or
+ ~azure.mgmt.batch.types.CheckNameAvailabilityParameters or IO[bytes]
:return: CheckNameAvailabilityResult. The CheckNameAvailabilityResult is compatible with
MutableMapping
:rtype: ~azure.mgmt.batch.models.CheckNameAvailabilityResult
@@ -6892,6 +7004,7 @@ def check_name_availability(
}
_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
@@ -6913,7 +7026,7 @@ def check_name_availability(
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if _stream:
- deserialized = response.iter_bytes()
+ deserialized = response.iter_bytes() if _decompress else response.iter_raw()
else:
deserialized = _deserialize(_models.CheckNameAvailabilityResult, response.json())
diff --git a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/operations/_patch.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/operations/_patch.py
index 87676c65a8f0..ea765788358a 100644
--- a/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/operations/_patch.py
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/operations/_patch.py
@@ -8,7 +8,6 @@
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/batch/azure-mgmt-batch/azure/mgmt/batch/types.py b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/types.py
new file mode 100644
index 000000000000..97b52e4999f7
--- /dev/null
+++ b/sdk/batch/azure-mgmt-batch/azure/mgmt/batch/types.py
@@ -0,0 +1,2728 @@
+# pylint: disable=line-too-long,useless-suppression,too-many-lines
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from typing import Any, Optional, TYPE_CHECKING, Union
+from typing_extensions import Required, TypedDict
+
+if TYPE_CHECKING:
+ from .models import (
+ AccountKeyType,
+ AllocationState,
+ AuthenticationMode,
+ AutoStorageAuthenticationMode,
+ AutoUserScope,
+ CachingType,
+ ComputeNodeDeallocationOption,
+ ComputeNodeFillType,
+ ContainerHostDataPath,
+ ContainerType,
+ ContainerWorkingDirectory,
+ CreatedByType,
+ DiffDiskPlacement,
+ DiskEncryptionTarget,
+ DynamicVNetAssignmentScope,
+ ElevationLevel,
+ EndpointAccessDefaultAction,
+ HostEndpointSettingsModeTypes,
+ IPAddressProvisioningType,
+ IPFamily,
+ IPRuleAction,
+ InboundEndpointProtocol,
+ InterNodeCommunicationState,
+ JobDefaultOrder,
+ KeySource,
+ LoginMode,
+ NetworkSecurityGroupRuleAccess,
+ NodePlacementPolicyType,
+ PackageState,
+ PoolAllocationMode,
+ PoolIdentityType,
+ PoolProvisioningState,
+ PrivateEndpointConnectionProvisioningState,
+ PrivateLinkServiceConnectionStatus,
+ PublicNetworkAccessType,
+ RequestedComputeNodeDeallocationOption,
+ ResourceIdentityType,
+ ResourceType,
+ SecurityEncryptionTypes,
+ SecurityTypes,
+ StorageAccountType,
+ UpgradeMode,
+ VirtualMachineSkuAllocationStrategy,
+ ZonePlacementPolicyType,
+ )
+
+
+class ActivateApplicationPackageParameters(TypedDict, total=False):
+ """Parameters for an activating an application package.
+
+ :ivar format: The format of the application package binary file. Required.
+ :vartype format: str
+ """
+
+ format: Required[str]
+ """The format of the application package binary file. Required."""
+
+
+class Resource(TypedDict, total=False):
+ """Resource.
+
+ :ivar id: Fully qualified resource ID for the resource. Ex -
+ /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
+ :vartype id: str
+ :ivar name: The name of the resource.
+ :vartype name: str
+ :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
+ "Microsoft.Storage/storageAccounts".
+ :vartype type: str
+ :ivar systemData: Azure Resource Manager metadata containing createdBy and modifiedBy
+ information.
+ :vartype systemData: "SystemData"
+ """
+
+ id: str
+ """Fully qualified resource ID for the resource. Ex -
+ /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}."""
+ name: str
+ """The name of the resource."""
+ type: str
+ """The type of the resource. E.g. \"Microsoft.Compute/virtualMachines\" or
+ \"Microsoft.Storage/storageAccounts\"."""
+ systemData: "SystemData"
+ """Azure Resource Manager metadata containing createdBy and modifiedBy information."""
+
+
+class ProxyResource(Resource):
+ """Proxy Resource.
+
+ :ivar id: Fully qualified resource ID for the resource. Ex -
+ /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
+ :vartype id: str
+ :ivar name: The name of the resource.
+ :vartype name: str
+ :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
+ "Microsoft.Storage/storageAccounts".
+ :vartype type: str
+ :ivar systemData: Azure Resource Manager metadata containing createdBy and modifiedBy
+ information.
+ :vartype systemData: "SystemData"
+ """
+
+
+class Application(ProxyResource):
+ """Contains information about an application in a Batch account.
+
+ :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 systemData: Azure Resource Manager metadata containing createdBy and modifiedBy
+ information.
+ :vartype systemData: "SystemData"
+ :ivar properties: The properties associated with the Application.
+ :vartype properties: "ApplicationProperties"
+ :ivar etag: The ETag of the resource, used for concurrency statements.
+ :vartype etag: str
+ :ivar tags: The tags of the resource.
+ :vartype tags: dict[str, str]
+ """
+
+ properties: "ApplicationProperties"
+ """The properties associated with the Application."""
+ etag: str
+ """The ETag of the resource, used for concurrency statements."""
+ tags: dict[str, str]
+ """The tags of the resource."""
+
+
+class ApplicationPackage(ProxyResource):
+ """An application package which represents a particular version of an application.
+
+ :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 systemData: Azure Resource Manager metadata containing createdBy and modifiedBy
+ information.
+ :vartype systemData: "SystemData"
+ :ivar properties: The properties associated with the Application Package.
+ :vartype properties: "ApplicationPackageProperties"
+ :ivar etag: The ETag of the resource, used for concurrency statements.
+ :vartype etag: str
+ :ivar tags: The tags of the resource.
+ :vartype tags: dict[str, str]
+ """
+
+ properties: "ApplicationPackageProperties"
+ """The properties associated with the Application Package."""
+ etag: str
+ """The ETag of the resource, used for concurrency statements."""
+ tags: dict[str, str]
+ """The tags of the resource."""
+
+
+class ApplicationPackageProperties(TypedDict, total=False):
+ """Properties of an application package.
+
+ :ivar state: The current state of the application package. Known values are: "Pending" and
+ "Active".
+ :vartype state: Union[str, "PackageState"]
+ :ivar format: The format of the application package, if the package is active.
+ :vartype format: str
+ :ivar storageUrl: The URL for the application package in Azure Storage. This property is only
+ returned for the PUT application package (create or update) operation. For the GET application
+ package and POST activate application package operations, this property is not populated.
+ :vartype storageUrl: str
+ :ivar storageUrlExpiry: The UTC time at which the Azure Storage URL will expire. This property
+ is only returned for the PUT application package (create or update) operation. For the GET
+ application package and POST activate application package operations, this property is not
+ populated.
+ :vartype storageUrlExpiry: str
+ :ivar lastActivationTime: The time at which the package was last activated, if the package is
+ active.
+ :vartype lastActivationTime: str
+ """
+
+ state: Union[str, "PackageState"]
+ """The current state of the application package. Known values are: \"Pending\" and \"Active\"."""
+ format: str
+ """The format of the application package, if the package is active."""
+ storageUrl: str
+ """The URL for the application package in Azure Storage. This property is only returned for the
+ PUT application package (create or update) operation. For the GET application package and POST
+ activate application package operations, this property is not populated."""
+ storageUrlExpiry: str
+ """The UTC time at which the Azure Storage URL will expire. This property is only returned for the
+ PUT application package (create or update) operation. For the GET application package and POST
+ activate application package operations, this property is not populated."""
+ lastActivationTime: str
+ """The time at which the package was last activated, if the package is active."""
+
+
+class ApplicationPackageReference(TypedDict, total=False):
+ """Link to an application package inside the batch account.
+
+ :ivar id: The ID of the application package to install. This must be inside the same Batch
+ account as the pool. This can either be a reference to a specific version or the default
+ version if one exists. Required.
+ :vartype id: str
+ :ivar version: The version of the application to deploy. If omitted, the default version is
+ deployed.
+ :vartype version: str
+ """
+
+ id: Required[str]
+ """The ID of the application package to install. This must be inside the same Batch account as the
+ pool. This can either be a reference to a specific version or the default version if one
+ exists. Required."""
+ version: str
+ """The version of the application to deploy. If omitted, the default version is deployed."""
+
+
+class ApplicationProperties(TypedDict, total=False):
+ """The properties associated with the Application.
+
+ :ivar displayName: The display name for the application.
+ :vartype displayName: str
+ :ivar allowUpdates: A value indicating whether packages within the application may be
+ overwritten using the same version string.
+ :vartype allowUpdates: bool
+ :ivar defaultVersion: The package to use if a client requests the application but does not
+ specify a version. This property can only be set to the name of an existing package.
+ :vartype defaultVersion: str
+ """
+
+ displayName: str
+ """The display name for the application."""
+ allowUpdates: bool
+ """A value indicating whether packages within the application may be overwritten using the same
+ version string."""
+ defaultVersion: str
+ """The package to use if a client requests the application but does not specify a version. This
+ property can only be set to the name of an existing package."""
+
+
+class AutomaticOSUpgradePolicy(TypedDict, total=False):
+ """The configuration parameters used for performing automatic OS upgrade.
+
+ :ivar disableAutomaticRollback: Whether OS image rollback feature should be disabled.
+ :vartype disableAutomaticRollback: bool
+ :ivar enableAutomaticOSUpgrade: Indicates whether OS upgrades should automatically be applied
+ to scale set instances in a rolling fashion when a newer version of the OS image becomes
+ available.
If this is set to true for Windows based pools,
+ `WindowsConfiguration.enableAutomaticUpdates
+ `_
+ cannot be set to true.
+ :vartype enableAutomaticOSUpgrade: bool
+ :ivar useRollingUpgradePolicy: Indicates whether rolling upgrade policy should be used during
+ Auto OS Upgrade. Auto OS Upgrade will fallback to the default policy if no policy is defined on
+ the VMSS.
+ :vartype useRollingUpgradePolicy: bool
+ :ivar osRollingUpgradeDeferral: Defer OS upgrades on the TVMs if they are running tasks.
+ :vartype osRollingUpgradeDeferral: bool
+ """
+
+ disableAutomaticRollback: bool
+ """Whether OS image rollback feature should be disabled."""
+ enableAutomaticOSUpgrade: bool
+ """Indicates whether OS upgrades should automatically be applied to scale set instances in a
+ rolling fashion when a newer version of the OS image becomes available.
If this is
+ set to true for Windows based pools, `WindowsConfiguration.enableAutomaticUpdates
+ `_
+ cannot be set to true."""
+ useRollingUpgradePolicy: bool
+ """Indicates whether rolling upgrade policy should be used during Auto OS Upgrade. Auto OS Upgrade
+ will fallback to the default policy if no policy is defined on the VMSS."""
+ osRollingUpgradeDeferral: bool
+ """Defer OS upgrades on the TVMs if they are running tasks."""
+
+
+class AutoScaleRun(TypedDict, total=False):
+ """The results and errors from an execution of a pool autoscale formula.
+
+ :ivar evaluationTime: The time at which the autoscale formula was last evaluated. Required.
+ :vartype evaluationTime: str
+ :ivar results: The final values of all variables used in the evaluation of the autoscale
+ formula.
+ :vartype results: str
+ :ivar error: Details of the error encountered evaluating the autoscale formula on the pool, if
+ the evaluation was unsuccessful.
+ :vartype error: "AutoScaleRunError"
+ """
+
+ evaluationTime: Required[str]
+ """The time at which the autoscale formula was last evaluated. Required."""
+ results: str
+ """The final values of all variables used in the evaluation of the autoscale formula."""
+ error: "AutoScaleRunError"
+ """Details of the error encountered evaluating the autoscale formula on the pool, if the
+ evaluation was unsuccessful."""
+
+
+class AutoScaleRunError(TypedDict, total=False):
+ """An error that occurred when autoscaling a pool.
+
+ :ivar code: An identifier for the error. Codes are invariant and are intended to be consumed
+ programmatically. Required.
+ :vartype code: str
+ :ivar message: A message describing the error, intended to be suitable for display in a user
+ interface. Required.
+ :vartype message: str
+ :ivar details: Additional details about the error.
+ :vartype details: list["AutoScaleRunError"]
+ """
+
+ code: Required[str]
+ """An identifier for the error. Codes are invariant and are intended to be consumed
+ programmatically. Required."""
+ message: Required[str]
+ """A message describing the error, intended to be suitable for display in a user interface.
+ Required."""
+ details: list["AutoScaleRunError"]
+ """Additional details about the error."""
+
+
+class AutoScaleSettings(TypedDict, total=False):
+ """AutoScale settings for the pool.
+
+ :ivar formula: A formula for the desired number of compute nodes in the pool. Required.
+ :vartype formula: str
+ :ivar evaluationInterval: The time interval at which to automatically adjust the pool size
+ according to the autoscale formula.
+ :vartype evaluationInterval: str
+ """
+
+ formula: Required[str]
+ """A formula for the desired number of compute nodes in the pool. Required."""
+ evaluationInterval: str
+ """The time interval at which to automatically adjust the pool size according to the autoscale
+ formula."""
+
+
+class AutoStorageBaseProperties(TypedDict, total=False):
+ """The properties related to the auto-storage account.
+
+ :ivar storageAccountId: The resource ID of the storage account to be used for auto-storage
+ account. Required.
+ :vartype storageAccountId: str
+ :ivar authenticationMode: The authentication mode which the Batch service will use to manage
+ the auto-storage account. Known values are: "StorageKeys" and "BatchAccountManagedIdentity".
+ :vartype authenticationMode: Union[str, "AutoStorageAuthenticationMode"]
+ :ivar nodeIdentityReference: The reference to the user assigned identity which compute nodes
+ will use to access auto-storage.
+ :vartype nodeIdentityReference: "ComputeNodeIdentityReference"
+ """
+
+ storageAccountId: Required[str]
+ """The resource ID of the storage account to be used for auto-storage account. Required."""
+ authenticationMode: Union[str, "AutoStorageAuthenticationMode"]
+ """The authentication mode which the Batch service will use to manage the auto-storage account.
+ Known values are: \"StorageKeys\" and \"BatchAccountManagedIdentity\"."""
+ nodeIdentityReference: "ComputeNodeIdentityReference"
+ """The reference to the user assigned identity which compute nodes will use to access
+ auto-storage."""
+
+
+class AutoUserSpecification(TypedDict, total=False):
+ """Specifies the parameters for the auto user that runs a task on the Batch service.
+
+ :ivar scope: The scope for the auto user. Known values are: "Task" and "Pool".
+ :vartype scope: Union[str, "AutoUserScope"]
+ :ivar elevationLevel: The elevation level of the user. Known values are: "NonAdmin" and
+ "Admin".
+ :vartype elevationLevel: Union[str, "ElevationLevel"]
+ """
+
+ scope: Union[str, "AutoUserScope"]
+ """The scope for the auto user. Known values are: \"Task\" and \"Pool\"."""
+ elevationLevel: Union[str, "ElevationLevel"]
+ """The elevation level of the user. Known values are: \"NonAdmin\" and \"Admin\"."""
+
+
+class AzureBlobFileSystemConfiguration(TypedDict, total=False):
+ """Information used to connect to an Azure Storage Container using Blobfuse.
+
+ :ivar accountName: The Azure Storage Account name. Required.
+ :vartype accountName: str
+ :ivar containerName: The Azure Blob Storage Container name. Required.
+ :vartype containerName: str
+ :ivar accountKey: The Azure Storage Account key.
+ :vartype accountKey: str
+ :ivar sasKey: The Azure Storage SAS token.
+ :vartype sasKey: str
+ :ivar blobfuseOptions: Additional command line options to pass to the mount command.
+ :vartype blobfuseOptions: str
+ :ivar relativeMountPath: The relative path on the compute node where the file system will be
+ mounted. Required.
+ :vartype relativeMountPath: str
+ :ivar identityReference: The reference to the user assigned identity to use to access
+ containerName.
+ :vartype identityReference: "ComputeNodeIdentityReference"
+ """
+
+ accountName: Required[str]
+ """The Azure Storage Account name. Required."""
+ containerName: Required[str]
+ """The Azure Blob Storage Container name. Required."""
+ accountKey: str
+ """The Azure Storage Account key."""
+ sasKey: str
+ """The Azure Storage SAS token."""
+ blobfuseOptions: str
+ """Additional command line options to pass to the mount command."""
+ relativeMountPath: Required[str]
+ """The relative path on the compute node where the file system will be mounted. Required."""
+ identityReference: "ComputeNodeIdentityReference"
+ """The reference to the user assigned identity to use to access containerName."""
+
+
+class AzureFileShareConfiguration(TypedDict, total=False):
+ """Information used to connect to an Azure Fileshare.
+
+ :ivar accountName: The Azure Storage account name. Required.
+ :vartype accountName: str
+ :ivar azureFileUrl: The Azure Files URL. Required.
+ :vartype azureFileUrl: str
+ :ivar accountKey: The Azure Storage account key. Required.
+ :vartype accountKey: str
+ :ivar relativeMountPath: The relative path on the compute node where the file system will be
+ mounted. Required.
+ :vartype relativeMountPath: str
+ :ivar mountOptions: Additional command line options to pass to the mount command.
+ :vartype mountOptions: str
+ """
+
+ accountName: Required[str]
+ """The Azure Storage account name. Required."""
+ azureFileUrl: Required[str]
+ """The Azure Files URL. Required."""
+ accountKey: Required[str]
+ """The Azure Storage account key. Required."""
+ relativeMountPath: Required[str]
+ """The relative path on the compute node where the file system will be mounted. Required."""
+ mountOptions: str
+ """Additional command line options to pass to the mount command."""
+
+
+class BatchAccountCreateParameters(TypedDict, total=False):
+ """Parameters supplied to the Create operation.
+
+ :ivar location: The region in which to create the account. Required.
+ :vartype location: str
+ :ivar tags: The user-specified tags associated with the account.
+ :vartype tags: dict[str, str]
+ :ivar properties: The properties of the Batch account.
+ :vartype properties: "BatchAccountCreateProperties"
+ :ivar identity: The identity of the Batch account.
+ :vartype identity: "BatchAccountIdentity"
+ """
+
+ location: Required[str]
+ """The region in which to create the account. Required."""
+ tags: dict[str, str]
+ """The user-specified tags associated with the account."""
+ properties: "BatchAccountCreateProperties"
+ """The properties of the Batch account."""
+ identity: "BatchAccountIdentity"
+ """The identity of the Batch account."""
+
+
+class BatchAccountCreateProperties(TypedDict, total=False):
+ """The properties of a Batch account.
+
+ :ivar autoStorage: The properties related to the auto-storage account.
+ :vartype autoStorage: "AutoStorageBaseProperties"
+ :ivar poolAllocationMode: The allocation mode to use for creating pools in the Batch account.
+ Known values are: "BatchService" and "UserSubscription".
+ :vartype poolAllocationMode: Union[str, "PoolAllocationMode"]
+ :ivar keyVaultReference: A reference to the Azure key vault associated with the Batch account.
+ :vartype keyVaultReference: "KeyVaultReference"
+ :ivar publicNetworkAccess: The network access type for accessing Azure Batch account. Known
+ values are: "Enabled", "Disabled", and "SecuredByPerimeter".
+ :vartype publicNetworkAccess: Union[str, "PublicNetworkAccessType"]
+ :ivar networkProfile: Network profile for Batch account, which contains network rule settings
+ for each endpoint.
+ :vartype networkProfile: "NetworkProfile"
+ :ivar encryption: The encryption configuration for the Batch account.
+ :vartype encryption: "EncryptionProperties"
+ :ivar allowedAuthenticationModes: List of allowed authentication modes for the Batch account
+ that can be used to authenticate with the data plane. This does not affect authentication with
+ the control plane.
+ :vartype allowedAuthenticationModes: list[Union[str, "AuthenticationMode"]]
+ """
+
+ autoStorage: "AutoStorageBaseProperties"
+ """The properties related to the auto-storage account."""
+ poolAllocationMode: Union[str, "PoolAllocationMode"]
+ """The allocation mode to use for creating pools in the Batch account. Known values are:
+ \"BatchService\" and \"UserSubscription\"."""
+ keyVaultReference: "KeyVaultReference"
+ """A reference to the Azure key vault associated with the Batch account."""
+ publicNetworkAccess: Union[str, "PublicNetworkAccessType"]
+ """The network access type for accessing Azure Batch account. Known values are: \"Enabled\",
+ \"Disabled\", and \"SecuredByPerimeter\"."""
+ networkProfile: "NetworkProfile"
+ """Network profile for Batch account, which contains network rule settings for each endpoint."""
+ encryption: "EncryptionProperties"
+ """The encryption configuration for the Batch account."""
+ allowedAuthenticationModes: Optional[list[Union[str, "AuthenticationMode"]]]
+ """List of allowed authentication modes for the Batch account that can be used to authenticate
+ with the data plane. This does not affect authentication with the control plane."""
+
+
+class BatchAccountIdentity(TypedDict, total=False):
+ """The identity of the Batch account, if configured. This is used when the user specifies
+ 'Microsoft.KeyVault' as their Batch account encryption configuration or when
+ ``ManagedIdentity`` is selected as the auto-storage authentication mode.
+
+ :ivar principalId: The principal id of the Batch account. This property will only be provided
+ for a system assigned identity.
+ :vartype principalId: str
+ :ivar tenantId: The tenant id associated with the Batch account. This property will only be
+ provided for a system assigned identity.
+ :vartype tenantId: str
+ :ivar type: The type of identity used for the Batch account. Required. Known values are:
+ "SystemAssigned", "UserAssigned", and "None".
+ :vartype type: Union[str, "ResourceIdentityType"]
+ :ivar userAssignedIdentities: The list of user identities associated with the Batch account.
+ :vartype userAssignedIdentities: dict[str, "UserAssignedIdentities"]
+ """
+
+ principalId: str
+ """The principal id of the Batch account. This property will only be provided for a system
+ assigned identity."""
+ tenantId: str
+ """The tenant id associated with the Batch account. This property will only be provided for a
+ system assigned identity."""
+ type: Required[Union[str, "ResourceIdentityType"]]
+ """The type of identity used for the Batch account. Required. Known values are:
+ \"SystemAssigned\", \"UserAssigned\", and \"None\"."""
+ userAssignedIdentities: dict[str, "UserAssignedIdentities"]
+ """The list of user identities associated with the Batch account."""
+
+
+class BatchAccountRegenerateKeyParameters(TypedDict, total=False):
+ """Parameters supplied to the RegenerateKey operation.
+
+ :ivar keyName: The type of account key to regenerate. Required. Known values are: "Primary" and
+ "Secondary".
+ :vartype keyName: Union[str, "AccountKeyType"]
+ """
+
+ keyName: Required[Union[str, "AccountKeyType"]]
+ """The type of account key to regenerate. Required. Known values are: \"Primary\" and
+ \"Secondary\"."""
+
+
+class BatchAccountUpdateParameters(TypedDict, total=False):
+ """Parameters for updating an Azure Batch account.
+
+ :ivar tags: The user-specified tags associated with the account.
+ :vartype tags: dict[str, str]
+ :ivar properties: The properties of the account.
+ :vartype properties: "BatchAccountUpdateProperties"
+ :ivar identity: The identity of the Batch account.
+ :vartype identity: "BatchAccountIdentity"
+ """
+
+ tags: dict[str, str]
+ """The user-specified tags associated with the account."""
+ properties: "BatchAccountUpdateProperties"
+ """The properties of the account."""
+ identity: "BatchAccountIdentity"
+ """The identity of the Batch account."""
+
+
+class BatchAccountUpdateProperties(TypedDict, total=False):
+ """The properties of a Batch account.
+
+ :ivar autoStorage: The properties related to the auto-storage account.
+ :vartype autoStorage: "AutoStorageBaseProperties"
+ :ivar encryption: The encryption configuration for the Batch account.
+ :vartype encryption: "EncryptionProperties"
+ :ivar allowedAuthenticationModes: List of allowed authentication modes for the Batch account
+ that can be used to authenticate with the data plane. This does not affect authentication with
+ the control plane.
+ :vartype allowedAuthenticationModes: list[Union[str, "AuthenticationMode"]]
+ :ivar publicNetworkAccess: The network access type for accessing Azure Batch account. Known
+ values are: "Enabled", "Disabled", and "SecuredByPerimeter".
+ :vartype publicNetworkAccess: Union[str, "PublicNetworkAccessType"]
+ :ivar networkProfile: Network profile for Batch account, which contains network rule settings
+ for each endpoint.
+ :vartype networkProfile: "NetworkProfile"
+ """
+
+ autoStorage: "AutoStorageBaseProperties"
+ """The properties related to the auto-storage account."""
+ encryption: "EncryptionProperties"
+ """The encryption configuration for the Batch account."""
+ allowedAuthenticationModes: Optional[list[Union[str, "AuthenticationMode"]]]
+ """List of allowed authentication modes for the Batch account that can be used to authenticate
+ with the data plane. This does not affect authentication with the control plane."""
+ publicNetworkAccess: Union[str, "PublicNetworkAccessType"]
+ """The network access type for accessing Azure Batch account. Known values are: \"Enabled\",
+ \"Disabled\", and \"SecuredByPerimeter\"."""
+ networkProfile: "NetworkProfile"
+ """Network profile for Batch account, which contains network rule settings for each endpoint."""
+
+
+class BatchPoolIdentity(TypedDict, total=False):
+ """The identity of the Batch pool, if configured. If the pool identity is updated during update an
+ existing pool, only the new vms which are created after the pool shrinks to 0 will have the
+ updated identities.
+
+ :ivar type: The type of identity used for the Batch Pool. Required. Known values are:
+ "UserAssigned" and "None".
+ :vartype type: Union[str, "PoolIdentityType"]
+ :ivar userAssignedIdentities: The list of user identities associated with the Batch pool.
+ :vartype userAssignedIdentities: dict[str, "UserAssignedIdentities"]
+ """
+
+ type: Required[Union[str, "PoolIdentityType"]]
+ """The type of identity used for the Batch Pool. Required. Known values are: \"UserAssigned\" and
+ \"None\"."""
+ userAssignedIdentities: dict[str, "UserAssignedIdentities"]
+ """The list of user identities associated with the Batch pool."""
+
+
+class CheckNameAvailabilityParameters(TypedDict, total=False):
+ """Parameters for a check name availability request.
+
+ :ivar name: The name to check for availability. Required.
+ :vartype name: str
+ :ivar type: The resource type. Required. "Microsoft.Batch/batchAccounts"
+ :vartype type: Union[str, "ResourceType"]
+ """
+
+ name: Required[str]
+ """The name to check for availability. Required."""
+ type: Required[Union[str, "ResourceType"]]
+ """The resource type. Required. \"Microsoft.Batch/batchAccounts\""""
+
+
+class CIFSMountConfiguration(TypedDict, total=False):
+ """Information used to connect to a CIFS file system.
+
+ :ivar userName: The user to use for authentication against the CIFS file system. Required.
+ :vartype userName: str
+ :ivar source: The URI of the file system to mount. Required.
+ :vartype source: str
+ :ivar relativeMountPath: The relative path on the compute node where the file system will be
+ mounted. Required.
+ :vartype relativeMountPath: str
+ :ivar mountOptions: Additional command line options to pass to the mount command.
+ :vartype mountOptions: str
+ :ivar password: The password to use for authentication against the CIFS file system. Required.
+ :vartype password: str
+ """
+
+ userName: Required[str]
+ """The user to use for authentication against the CIFS file system. Required."""
+ source: Required[str]
+ """The URI of the file system to mount. Required."""
+ relativeMountPath: Required[str]
+ """The relative path on the compute node where the file system will be mounted. Required."""
+ mountOptions: str
+ """Additional command line options to pass to the mount command."""
+ password: Required[str]
+ """The password to use for authentication against the CIFS file system. Required."""
+
+
+class ComputeNodeIdentityReference(TypedDict, total=False):
+ """The reference to a user assigned identity associated with the Batch pool which a compute node
+ will use.
+
+ :ivar resourceId: The ARM resource id of the user assigned identity.
+ :vartype resourceId: str
+ """
+
+ resourceId: str
+ """The ARM resource id of the user assigned identity."""
+
+
+class ContainerConfiguration(TypedDict, total=False):
+ """The configuration for container-enabled pools.
+
+ :ivar type: The container technology to be used. Required. Known values are: "DockerCompatible"
+ and "CriCompatible".
+ :vartype type: Union[str, "ContainerType"]
+ :ivar containerImageNames: The collection of container image names.
+ :vartype containerImageNames: list[str]
+ :ivar containerRegistries: Additional private registries from which containers can be pulled.
+ :vartype containerRegistries: list["ContainerRegistry"]
+ """
+
+ type: Required[Union[str, "ContainerType"]]
+ """The container technology to be used. Required. Known values are: \"DockerCompatible\" and
+ \"CriCompatible\"."""
+ containerImageNames: list[str]
+ """The collection of container image names."""
+ containerRegistries: list["ContainerRegistry"]
+ """Additional private registries from which containers can be pulled."""
+
+
+class ContainerHostBatchBindMountEntry(TypedDict, total=False):
+ """The entry of path and mount mode you want to mount into task container.
+
+ :ivar source: The paths which will be mounted to container task's container. Known values are:
+ "Shared", "Startup", "VfsMounts", "Task", "JobPrep", and "Applications".
+ :vartype source: Union[str, "ContainerHostDataPath"]
+ :ivar isReadOnly: Mount this source path as read-only mode or not. Default value is false
+ (read/write mode).
+ :vartype isReadOnly: bool
+ """
+
+ source: Union[str, "ContainerHostDataPath"]
+ """The paths which will be mounted to container task's container. Known values are: \"Shared\",
+ \"Startup\", \"VfsMounts\", \"Task\", \"JobPrep\", and \"Applications\"."""
+ isReadOnly: bool
+ """Mount this source path as read-only mode or not. Default value is false (read/write mode)."""
+
+
+class ContainerRegistry(TypedDict, total=False):
+ """A private container registry.
+
+ :ivar username: The user name to log into the registry server.
+ :vartype username: str
+ :ivar password: The password to log into the registry server.
+ :vartype password: str
+ :ivar registryServer: The registry URL.
+ :vartype registryServer: str
+ :ivar identityReference: The reference to the user assigned identity to use to access an Azure
+ Container Registry instead of username and password.
+ :vartype identityReference: "ComputeNodeIdentityReference"
+ """
+
+ username: str
+ """The user name to log into the registry server."""
+ password: str
+ """The password to log into the registry server."""
+ registryServer: str
+ """The registry URL."""
+ identityReference: "ComputeNodeIdentityReference"
+ """The reference to the user assigned identity to use to access an Azure Container Registry
+ instead of username and password."""
+
+
+class DataDisk(TypedDict, total=False):
+ """Settings which will be used by the data disks associated to Compute Nodes in the Pool. When
+ using attached data disks, you need to mount and format the disks from within a VM to use them.
+
+ :ivar lun: The logical unit number. Required.
+ :vartype lun: int
+ :ivar caching: The type of caching to enable for the disk. Known values are: "None",
+ "ReadOnly", and "ReadWrite".
+ :vartype caching: Union[str, "CachingType"]
+ :ivar diskSizeGB: The initial disk size in GB when creating new data disk. Required.
+ :vartype diskSizeGB: int
+ :ivar managedDisk: The managed disk parameters.
+ :vartype managedDisk: "ManagedDisk"
+ """
+
+ lun: Required[int]
+ """The logical unit number. Required."""
+ caching: Union[str, "CachingType"]
+ """The type of caching to enable for the disk. Known values are: \"None\", \"ReadOnly\", and
+ \"ReadWrite\"."""
+ diskSizeGB: Required[int]
+ """The initial disk size in GB when creating new data disk. Required."""
+ managedDisk: "ManagedDisk"
+ """The managed disk parameters."""
+
+
+class DeploymentConfiguration(TypedDict, total=False):
+ """Deployment configuration properties.
+
+ :ivar virtualMachineConfiguration: The virtual machine configuration for the pool.
+ :vartype virtualMachineConfiguration: "VirtualMachineConfiguration"
+ """
+
+ virtualMachineConfiguration: "VirtualMachineConfiguration"
+ """The virtual machine configuration for the pool."""
+
+
+class DeploymentConfigurationPatch(TypedDict, total=False):
+ """Deployment settings with partial updates for the new zone policies.
+
+ :ivar virtualMachineConfiguration: The virtual machine configuration for the pool.
+ :vartype virtualMachineConfiguration: "VirtualMachineConfigurationPatch"
+ """
+
+ virtualMachineConfiguration: "VirtualMachineConfigurationPatch"
+ """The virtual machine configuration for the pool."""
+
+
+class DiffDiskSettings(TypedDict, total=False):
+ """Specifies the ephemeral Disk Settings for the operating system disk used by the virtual
+ machine.
+
+ :ivar placement: Specifies the ephemeral disk placement for operating system disk for all VMs
+ in the pool. "CacheDisk"
+ :vartype placement: Union[str, "DiffDiskPlacement"]
+ """
+
+ placement: Union[str, "DiffDiskPlacement"]
+ """Specifies the ephemeral disk placement for operating system disk for all VMs in the pool.
+ \"CacheDisk\""""
+
+
+class DiskCustomerManagedKey(TypedDict, total=False):
+ """The Customer Managed Key reference to encrypt the Disk.
+
+ :ivar keyUrl: Fully versioned Key Url pointing to a key in KeyVault. Version segment of the Url
+ is required regardless of rotationToLatestKeyVersionEnabled value.
+ :vartype keyUrl: str
+ :ivar rotationToLatestKeyVersionEnabled: Set this flag to true to enable auto-updating of the
+ Disk Encryption to the latest key version. Default is false.
+ :vartype rotationToLatestKeyVersionEnabled: bool
+ :ivar identityReference: The reference of one of the pool identities to encrypt Disk. This
+ identity will be used to access the KeyVault.
+ :vartype identityReference: "ComputeNodeIdentityReference"
+ """
+
+ keyUrl: str
+ """Fully versioned Key Url pointing to a key in KeyVault. Version segment of the Url is required
+ regardless of rotationToLatestKeyVersionEnabled value."""
+ rotationToLatestKeyVersionEnabled: bool
+ """Set this flag to true to enable auto-updating of the Disk Encryption to the latest key version.
+ Default is false."""
+ identityReference: "ComputeNodeIdentityReference"
+ """The reference of one of the pool identities to encrypt Disk. This identity will be used to
+ access the KeyVault."""
+
+
+class DiskEncryptionConfiguration(TypedDict, total=False):
+ """The disk encryption configuration applied on compute nodes in the pool. Disk encryption
+ configuration is not supported on Linux pool created with Virtual Machine Image or Azure
+ Compute Gallery Image.
+
+ :ivar targets: The list of disk targets Batch Service will encrypt on the compute node.
+ :vartype targets: list[Union[str, "DiskEncryptionTarget"]]
+ :ivar customerManagedKey: The Customer Managed Key reference to encrypt the OS Disk.
+ :vartype customerManagedKey: "DiskCustomerManagedKey"
+ """
+
+ targets: list[Union[str, "DiskEncryptionTarget"]]
+ """The list of disk targets Batch Service will encrypt on the compute node."""
+ customerManagedKey: "DiskCustomerManagedKey"
+ """The Customer Managed Key reference to encrypt the OS Disk."""
+
+
+class DiskEncryptionSetParameters(TypedDict, total=False):
+ """The ARM resource id of the disk encryption set.
+
+ :ivar id: The resource id of the disk encryption set. Required.
+ :vartype id: str
+ """
+
+ id: Required[str]
+ """The resource id of the disk encryption set. Required."""
+
+
+class EncryptionProperties(TypedDict, total=False):
+ """Configures how customer data is encrypted inside the Batch account. By default, accounts are
+ encrypted using a Microsoft managed key. For additional control, a customer-managed key can be
+ used instead.
+
+ :ivar keySource: Type of the key source. Known values are: "Microsoft.Batch" and
+ "Microsoft.KeyVault".
+ :vartype keySource: Union[str, "KeySource"]
+ :ivar keyVaultProperties: Additional details when using Microsoft.KeyVault.
+ :vartype keyVaultProperties: "KeyVaultProperties"
+ """
+
+ keySource: Union[str, "KeySource"]
+ """Type of the key source. Known values are: \"Microsoft.Batch\" and \"Microsoft.KeyVault\"."""
+ keyVaultProperties: "KeyVaultProperties"
+ """Additional details when using Microsoft.KeyVault."""
+
+
+class EndpointAccessProfile(TypedDict, total=False):
+ """Network access profile for Batch endpoint.
+
+ :ivar defaultAction: The default action when there is no IPRule matched. Required. Known values
+ are: "Allow" and "Deny".
+ :vartype defaultAction: Union[str, "EndpointAccessDefaultAction"]
+ :ivar ipRules: Array of IP ranges to filter client IP address.
+ :vartype ipRules: list["IPRule"]
+ """
+
+ defaultAction: Required[Union[str, "EndpointAccessDefaultAction"]]
+ """The default action when there is no IPRule matched. Required. Known values are: \"Allow\" and
+ \"Deny\"."""
+ ipRules: list["IPRule"]
+ """Array of IP ranges to filter client IP address."""
+
+
+class EnvironmentSetting(TypedDict, total=False):
+ """An environment variable to be set on a task process.
+
+ :ivar name: The name of the environment variable. Required.
+ :vartype name: str
+ :ivar value: The value of the environment variable.
+ :vartype value: str
+ """
+
+ name: Required[str]
+ """The name of the environment variable. Required."""
+ value: str
+ """The value of the environment variable."""
+
+
+class FixedScaleSettings(TypedDict, total=False):
+ """Fixed scale settings for the pool.
+
+ :ivar resizeTimeout: The timeout for allocation of compute nodes to the pool.
+ :vartype resizeTimeout: str
+ :ivar targetDedicatedNodes: The desired number of dedicated compute nodes in the pool.
+ :vartype targetDedicatedNodes: int
+ :ivar targetLowPriorityNodes: The desired number of Spot/low-priority compute nodes in the
+ pool.
+ :vartype targetLowPriorityNodes: int
+ :ivar nodeDeallocationOption: Determines what to do with a node and its running task(s) after
+ it has been selected for deallocation. Known values are: "Requeue", "Terminate", and
+ "TaskCompletion".
+ :vartype nodeDeallocationOption: Union[str, "RequestedComputeNodeDeallocationOption"]
+ """
+
+ resizeTimeout: str
+ """The timeout for allocation of compute nodes to the pool."""
+ targetDedicatedNodes: int
+ """The desired number of dedicated compute nodes in the pool."""
+ targetLowPriorityNodes: int
+ """The desired number of Spot/low-priority compute nodes in the pool."""
+ nodeDeallocationOption: Union[str, "RequestedComputeNodeDeallocationOption"]
+ """Determines what to do with a node and its running task(s) after it has been selected for
+ deallocation. Known values are: \"Requeue\", \"Terminate\", and \"TaskCompletion\"."""
+
+
+class HardwareProfile(TypedDict, total=False):
+ """Specifies the hardware settings for the compute nodes.
+
+ :ivar vmSizeProperties: Specifies the properties for customizing the size of the virtual
+ machine.
+ :vartype vmSizeProperties: "VmSizeProperties"
+ """
+
+ vmSizeProperties: "VmSizeProperties"
+ """Specifies the properties for customizing the size of the virtual machine."""
+
+
+class HostEndpointSettings(TypedDict, total=False):
+ """Specifies particular host endpoint settings.
+
+ :ivar mode: Specifies the access control policy execution mode. Known values are: "Audit" and
+ "Enforce".
+ :vartype mode: Union[str, "HostEndpointSettingsModeTypes"]
+ :ivar inVMAccessControlProfileReferenceId: Specifies the reference to the
+ InVMAccessControlProfileVersion resource id in the form of
+ /subscriptions/{SubscriptionId}/resourceGroups/{ResourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/inVMAccessControlProfiles/{profile}/versions/{version}.
+ :vartype inVMAccessControlProfileReferenceId: str
+ """
+
+ mode: Union[str, "HostEndpointSettingsModeTypes"]
+ """Specifies the access control policy execution mode. Known values are: \"Audit\" and
+ \"Enforce\"."""
+ inVMAccessControlProfileReferenceId: str
+ """Specifies the reference to the InVMAccessControlProfileVersion resource id in the form of
+ /subscriptions/{SubscriptionId}/resourceGroups/{ResourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/inVMAccessControlProfiles/{profile}/versions/{version}."""
+
+
+class ImageReference(TypedDict, total=False):
+ """A reference to an Azure Virtual Machines Marketplace image or the Azure Image resource of a
+ custom Virtual Machine. To get the list of all imageReferences verified by Azure Batch, see the
+ 'List supported node agent SKUs' operation.
+
+ :ivar publisher: The publisher of the Azure Virtual Machines Marketplace image.
+ :vartype publisher: str
+ :ivar offer: The offer type of the Azure Virtual Machines Marketplace image.
+ :vartype offer: str
+ :ivar sku: The SKU of the Azure Virtual Machines Marketplace image.
+ :vartype sku: str
+ :ivar version: The version of the Azure Virtual Machines Marketplace image.
+ :vartype version: str
+ :ivar id: The ARM resource identifier of the Azure Compute Gallery Image. Compute Nodes in the
+ Pool will be created using this Image Id. This is of the form
+ /subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Compute/galleries/{galleryName}/images/{imageDefinitionName}/versions/{versionId}.
+ :vartype id: str
+ :ivar sharedGalleryImageId: The shared gallery image unique identifier.
+ :vartype sharedGalleryImageId: str
+ :ivar communityGalleryImageId: The community gallery image unique identifier.
+ :vartype communityGalleryImageId: str
+ """
+
+ publisher: str
+ """The publisher of the Azure Virtual Machines Marketplace image."""
+ offer: str
+ """The offer type of the Azure Virtual Machines Marketplace image."""
+ sku: str
+ """The SKU of the Azure Virtual Machines Marketplace image."""
+ version: str
+ """The version of the Azure Virtual Machines Marketplace image."""
+ id: str
+ """The ARM resource identifier of the Azure Compute Gallery Image. Compute Nodes in the Pool will
+ be created using this Image Id. This is of the form
+ /subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Compute/galleries/{galleryName}/images/{imageDefinitionName}/versions/{versionId}."""
+ sharedGalleryImageId: str
+ """The shared gallery image unique identifier."""
+ communityGalleryImageId: str
+ """The community gallery image unique identifier."""
+
+
+class InboundNatPool(TypedDict, total=False):
+ """A inbound NAT pool that can be used to address specific ports on compute nodes in a Batch pool
+ externally.
+
+ :ivar name: The name of the endpoint. Required.
+ :vartype name: str
+ :ivar protocol: The protocol of the endpoint. Required. Known values are: "TCP" and "UDP".
+ :vartype protocol: Union[str, "InboundEndpointProtocol"]
+ :ivar backendPort: The port number on the compute node. Required.
+ :vartype backendPort: int
+ :ivar frontendPortRangeStart: The first port number in the range of external ports that will be
+ used to provide inbound access to the backendPort on individual compute nodes. Required.
+ :vartype frontendPortRangeStart: int
+ :ivar frontendPortRangeEnd: The last port number in the range of external ports that will be
+ used to provide inbound access to the backendPort on individual compute nodes. Required.
+ :vartype frontendPortRangeEnd: int
+ :ivar networkSecurityGroupRules: A list of network security group rules that will be applied to
+ the endpoint.
+ :vartype networkSecurityGroupRules: list["NetworkSecurityGroupRule"]
+ """
+
+ name: Required[str]
+ """The name of the endpoint. Required."""
+ protocol: Required[Union[str, "InboundEndpointProtocol"]]
+ """The protocol of the endpoint. Required. Known values are: \"TCP\" and \"UDP\"."""
+ backendPort: Required[int]
+ """The port number on the compute node. Required."""
+ frontendPortRangeStart: Required[int]
+ """The first port number in the range of external ports that will be used to provide inbound
+ access to the backendPort on individual compute nodes. Required."""
+ frontendPortRangeEnd: Required[int]
+ """The last port number in the range of external ports that will be used to provide inbound access
+ to the backendPort on individual compute nodes. Required."""
+ networkSecurityGroupRules: list["NetworkSecurityGroupRule"]
+ """A list of network security group rules that will be applied to the endpoint."""
+
+
+class IPRule(TypedDict, total=False):
+ """Rule to filter client IP address.
+
+ :ivar action: Action when client IP address is matched. Required. "Allow"
+ :vartype action: Union[str, "IPRuleAction"]
+ :ivar value: The IP address or IP address range to filter. Required.
+ :vartype value: str
+ """
+
+ action: Required[Union[str, "IPRuleAction"]]
+ """Action when client IP address is matched. Required. \"Allow\""""
+ value: Required[str]
+ """The IP address or IP address range to filter. Required."""
+
+
+class IPTag(TypedDict, total=False):
+ """Specifies how tasks should be distributed across compute nodes.
+
+ :ivar ipTagType: The IP Tag type.
+ :vartype ipTagType: str
+ :ivar tag: The value of the IP tag associated with the public IP.
+ :vartype tag: str
+ """
+
+ ipTagType: str
+ """The IP Tag type."""
+ tag: str
+ """The value of the IP tag associated with the public IP."""
+
+
+class KeyVaultProperties(TypedDict, total=False):
+ """KeyVault configuration when using an encryption KeySource of Microsoft.KeyVault.
+
+ :ivar keyIdentifier: Full path to the secret with or without version. Example
+ `https://mykeyvault.vault.azure.net/keys/testkey/6e34a81fef704045975661e297a4c053
+ `_. or
+ `https://mykeyvault.vault.azure.net/keys/testkey
+ `_. To be usable the following prerequisites
+ must be met:
+
+ The Batch Account has a System Assigned identity
+ The account identity has been granted Key/Get, Key/Unwrap and Key/Wrap permissions
+ The KeyVault has soft-delete and purge protection enabled.
+ :vartype keyIdentifier: str
+ """
+
+ keyIdentifier: str
+ """Full path to the secret with or without version. Example
+ `https://mykeyvault.vault.azure.net/keys/testkey/6e34a81fef704045975661e297a4c053
+ `_. or
+ `https://mykeyvault.vault.azure.net/keys/testkey
+ `_. To be usable the following prerequisites
+ must be met:
+
+ The Batch Account has a System Assigned identity
+ The account identity has been granted Key/Get, Key/Unwrap and Key/Wrap permissions
+ The KeyVault has soft-delete and purge protection enabled."""
+
+
+class KeyVaultReference(TypedDict, total=False):
+ """Identifies the Azure key vault associated with a Batch account.
+
+ :ivar id: The resource ID of the Azure key vault associated with the Batch account. Required.
+ :vartype id: str
+ :ivar url: The URL of the Azure key vault associated with the Batch account. Required.
+ :vartype url: str
+ """
+
+ id: Required[str]
+ """The resource ID of the Azure key vault associated with the Batch account. Required."""
+ url: Required[str]
+ """The URL of the Azure key vault associated with the Batch account. Required."""
+
+
+class LinuxUserConfiguration(TypedDict, total=False):
+ """Properties used to create a user account on a Linux node.
+
+ :ivar uid: The user ID of the user account.
+ :vartype uid: int
+ :ivar gid: The group ID for the user account.
+ :vartype gid: int
+ :ivar sshPrivateKey: The SSH private key for the user account.
+ :vartype sshPrivateKey: str
+ """
+
+ uid: int
+ """The user ID of the user account."""
+ gid: int
+ """The group ID for the user account."""
+ sshPrivateKey: str
+ """The SSH private key for the user account."""
+
+
+class ManagedDisk(TypedDict, total=False):
+ """The managed disk parameters.
+
+ :ivar storageAccountType: The storage account type for use in creating data disks or OS disk.
+ Known values are: "Standard_LRS", "Premium_LRS", and "StandardSSD_LRS".
+ :vartype storageAccountType: Union[str, "StorageAccountType"]
+ :ivar securityProfile: Specifies the security profile for the managed disk.
+ :vartype securityProfile: "VMDiskSecurityProfile"
+ :ivar diskEncryptionSet: Specifies the customer managed disk encryption set resource id for the
+ managed disk. It can be set only in UserSubscription mode.
+ :vartype diskEncryptionSet: "DiskEncryptionSetParameters"
+ """
+
+ storageAccountType: Union[str, "StorageAccountType"]
+ """The storage account type for use in creating data disks or OS disk. Known values are:
+ \"Standard_LRS\", \"Premium_LRS\", and \"StandardSSD_LRS\"."""
+ securityProfile: "VMDiskSecurityProfile"
+ """Specifies the security profile for the managed disk."""
+ diskEncryptionSet: "DiskEncryptionSetParameters"
+ """Specifies the customer managed disk encryption set resource id for the managed disk. It can be
+ set only in UserSubscription mode."""
+
+
+class MaxInstancePercentPerZonePolicy(TypedDict, total=False):
+ """The policy that limits the percentage of pool instances that may be allocated in a single
+ availability zone.
+
+ :ivar enabled: Whether the maximum instance percentage policy is enabled.
+ :vartype enabled: bool
+ :ivar value: The maximum percentage of pool instances that may be allocated in a single
+ availability zone. Required.
+ :vartype value: int
+ """
+
+ enabled: bool
+ """Whether the maximum instance percentage policy is enabled."""
+ value: Required[int]
+ """The maximum percentage of pool instances that may be allocated in a single availability zone.
+ Required."""
+
+
+class MaxInstancePercentPerZonePolicyPatch(TypedDict, total=False):
+ """Per-zone instance percentage fields to update, leaving omitted fields unchanged.
+
+ :ivar enabled: Whether the maximum instance percentage policy is enabled.
+ :vartype enabled: bool
+ :ivar value: The maximum percentage of pool instances that may be allocated in a single
+ availability zone.
+ :vartype value: int
+ """
+
+ enabled: bool
+ """Whether the maximum instance percentage policy is enabled."""
+ value: int
+ """The maximum percentage of pool instances that may be allocated in a single availability zone."""
+
+
+class MetadataItem(TypedDict, total=False):
+ """A name-value pair associated with a Batch service resource.
+
+ :ivar name: The name of the metadata item. Required.
+ :vartype name: str
+ :ivar value: The value of the metadata item. Required.
+ :vartype value: str
+ """
+
+ name: Required[str]
+ """The name of the metadata item. Required."""
+ value: Required[str]
+ """The value of the metadata item. Required."""
+
+
+class MountConfiguration(TypedDict, total=False):
+ """The file system to mount on each node.
+
+ :ivar azureBlobFileSystemConfiguration: The Azure Storage Container to mount using blob FUSE on
+ each node.
+ :vartype azureBlobFileSystemConfiguration: "AzureBlobFileSystemConfiguration"
+ :ivar nfsMountConfiguration: The NFS file system to mount on each node.
+ :vartype nfsMountConfiguration: "NFSMountConfiguration"
+ :ivar cifsMountConfiguration: The CIFS/SMB file system to mount on each node.
+ :vartype cifsMountConfiguration: "CIFSMountConfiguration"
+ :ivar azureFileShareConfiguration: The Azure File Share to mount on each node.
+ :vartype azureFileShareConfiguration: "AzureFileShareConfiguration"
+ """
+
+ azureBlobFileSystemConfiguration: "AzureBlobFileSystemConfiguration"
+ """The Azure Storage Container to mount using blob FUSE on each node."""
+ nfsMountConfiguration: "NFSMountConfiguration"
+ """The NFS file system to mount on each node."""
+ cifsMountConfiguration: "CIFSMountConfiguration"
+ """The CIFS/SMB file system to mount on each node."""
+ azureFileShareConfiguration: "AzureFileShareConfiguration"
+ """The Azure File Share to mount on each node."""
+
+
+class NetworkConfiguration(TypedDict, total=False):
+ """The network configuration for a pool.
+
+ :ivar subnetId: The ARM resource identifier of the virtual network subnet which the compute
+ nodes of the pool will join. This is of the form
+ /subscriptions/{subscription}/resourceGroups/{group}/providers/{provider}/virtualNetworks/{network}/subnets/{subnet}.
+ :vartype subnetId: str
+ :ivar dynamicVnetAssignmentScope: The scope of dynamic vnet assignment. Known values are:
+ "none" and "job".
+ :vartype dynamicVnetAssignmentScope: Union[str, "DynamicVNetAssignmentScope"]
+ :ivar endpointConfiguration: The configuration for endpoints on compute nodes in the Batch
+ pool.
+ :vartype endpointConfiguration: "PoolEndpointConfiguration"
+ :ivar publicIPAddressConfiguration: The Public IPAddress configuration for Compute Nodes in the
+ Batch Pool.
+ :vartype publicIPAddressConfiguration: "PublicIPAddressConfiguration"
+ :ivar enableAcceleratedNetworking: Whether this pool should enable accelerated networking.
+ :vartype enableAcceleratedNetworking: bool
+ """
+
+ subnetId: str
+ """The ARM resource identifier of the virtual network subnet which the compute nodes of the pool
+ will join. This is of the form
+ /subscriptions/{subscription}/resourceGroups/{group}/providers/{provider}/virtualNetworks/{network}/subnets/{subnet}."""
+ dynamicVnetAssignmentScope: Union[str, "DynamicVNetAssignmentScope"]
+ """The scope of dynamic vnet assignment. Known values are: \"none\" and \"job\"."""
+ endpointConfiguration: "PoolEndpointConfiguration"
+ """The configuration for endpoints on compute nodes in the Batch pool."""
+ publicIPAddressConfiguration: "PublicIPAddressConfiguration"
+ """The Public IPAddress configuration for Compute Nodes in the Batch Pool."""
+ enableAcceleratedNetworking: bool
+ """Whether this pool should enable accelerated networking."""
+
+
+class NetworkProfile(TypedDict, total=False):
+ """Network profile for Batch account, which contains network rule settings for each endpoint.
+
+ :ivar accountAccess: Network access profile for batchAccount endpoint (Batch account data plane
+ API).
+ :vartype accountAccess: "EndpointAccessProfile"
+ :ivar nodeManagementAccess: Network access profile for nodeManagement endpoint (Batch service
+ managing compute nodes for Batch pools).
+ :vartype nodeManagementAccess: "EndpointAccessProfile"
+ """
+
+ accountAccess: "EndpointAccessProfile"
+ """Network access profile for batchAccount endpoint (Batch account data plane API)."""
+ nodeManagementAccess: "EndpointAccessProfile"
+ """Network access profile for nodeManagement endpoint (Batch service managing compute nodes for
+ Batch pools)."""
+
+
+class NetworkSecurityGroupRule(TypedDict, total=False):
+ """A network security group rule to apply to an inbound endpoint.
+
+ :ivar priority: The priority for this rule. Required.
+ :vartype priority: int
+ :ivar access: The action that should be taken for a specified IP address, subnet range or tag.
+ Required. Known values are: "Allow" and "Deny".
+ :vartype access: Union[str, "NetworkSecurityGroupRuleAccess"]
+ :ivar sourceAddressPrefix: The source address prefix or tag to match for the rule. Required.
+ :vartype sourceAddressPrefix: str
+ :ivar sourcePortRanges: The source port ranges to match for the rule.
+ :vartype sourcePortRanges: list[str]
+ """
+
+ priority: Required[int]
+ """The priority for this rule. Required."""
+ access: Required[Union[str, "NetworkSecurityGroupRuleAccess"]]
+ """The action that should be taken for a specified IP address, subnet range or tag. Required.
+ Known values are: \"Allow\" and \"Deny\"."""
+ sourceAddressPrefix: Required[str]
+ """The source address prefix or tag to match for the rule. Required."""
+ sourcePortRanges: list[str]
+ """The source port ranges to match for the rule."""
+
+
+class NFSMountConfiguration(TypedDict, total=False):
+ """Information used to connect to an NFS file system.
+
+ :ivar source: The URI of the file system to mount. Required.
+ :vartype source: str
+ :ivar relativeMountPath: The relative path on the compute node where the file system will be
+ mounted. Required.
+ :vartype relativeMountPath: str
+ :ivar mountOptions: Additional command line options to pass to the mount command.
+ :vartype mountOptions: str
+ """
+
+ source: Required[str]
+ """The URI of the file system to mount. Required."""
+ relativeMountPath: Required[str]
+ """The relative path on the compute node where the file system will be mounted. Required."""
+ mountOptions: str
+ """Additional command line options to pass to the mount command."""
+
+
+class NodePlacementConfiguration(TypedDict, total=False):
+ """Node placement configuration for Batch pools.
+
+ :ivar policy: Node placement Policy type on Batch pools. Known values are: "Regional" and
+ "Zonal".
+ :vartype policy: Union[str, "NodePlacementPolicyType"]
+ """
+
+ policy: Union[str, "NodePlacementPolicyType"]
+ """Node placement Policy type on Batch pools. Known values are: \"Regional\" and \"Zonal\"."""
+
+
+class OSDisk(TypedDict, total=False):
+ """Settings for the operating system disk of the virtual machine.
+
+ :ivar ephemeralOSDiskSettings: Specifies the ephemeral Disk Settings for the operating system
+ disk used by the virtual machine.
+ :vartype ephemeralOSDiskSettings: "DiffDiskSettings"
+ :ivar caching: The type of caching to enable for the disk. Known values are: "None",
+ "ReadOnly", and "ReadWrite".
+ :vartype caching: Union[str, "CachingType"]
+ :ivar managedDisk: The managed disk parameters.
+ :vartype managedDisk: "ManagedDisk"
+ :ivar diskSizeGB: The initial disk size in GB when creating new OS disk.
+ :vartype diskSizeGB: int
+ :ivar writeAcceleratorEnabled: Specifies whether writeAccelerator should be enabled or disabled
+ on the disk.
+ :vartype writeAcceleratorEnabled: bool
+ """
+
+ ephemeralOSDiskSettings: "DiffDiskSettings"
+ """Specifies the ephemeral Disk Settings for the operating system disk used by the virtual
+ machine."""
+ caching: Union[str, "CachingType"]
+ """The type of caching to enable for the disk. Known values are: \"None\", \"ReadOnly\", and
+ \"ReadWrite\"."""
+ managedDisk: "ManagedDisk"
+ """The managed disk parameters."""
+ diskSizeGB: int
+ """The initial disk size in GB when creating new OS disk."""
+ writeAcceleratorEnabled: bool
+ """Specifies whether writeAccelerator should be enabled or disabled on the disk."""
+
+
+class Placement(TypedDict, total=False):
+ """The placement policy for compute nodes in a pool.
+
+ :ivar zonePlacementPolicy: Auto delegates zone selection and balancing to the virtual machine
+ scale set. Required. "Auto"
+ :vartype zonePlacementPolicy: Union[str, "ZonePlacementPolicyType"]
+ """
+
+ zonePlacementPolicy: Required[Union[str, "ZonePlacementPolicyType"]]
+ """Auto delegates zone selection and balancing to the virtual machine scale set. Required.
+ \"Auto\""""
+
+
+class PlacementPatch(TypedDict, total=False):
+ """Availability zone placement fields to update, leaving omitted fields unchanged.
+
+ :ivar zonePlacementPolicy: Auto delegates zone selection and balancing to the virtual machine
+ scale set. "Auto"
+ :vartype zonePlacementPolicy: Union[str, "ZonePlacementPolicyType"]
+ """
+
+ zonePlacementPolicy: Union[str, "ZonePlacementPolicyType"]
+ """Auto delegates zone selection and balancing to the virtual machine scale set. \"Auto\""""
+
+
+class Pool(ProxyResource):
+ """Contains information about a pool.
+
+ :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 systemData: Azure Resource Manager metadata containing createdBy and modifiedBy
+ information.
+ :vartype systemData: "SystemData"
+ :ivar properties: The properties associated with the pool.
+ :vartype properties: "PoolProperties"
+ :ivar identity: The type of identity used for the Batch Pool.
+ :vartype identity: "BatchPoolIdentity"
+ :ivar etag: The ETag of the resource, used for concurrency statements.
+ :vartype etag: str
+ :ivar tags: The tags of the resource.
+ :vartype tags: dict[str, str]
+ """
+
+ properties: "PoolProperties"
+ """The properties associated with the pool."""
+ identity: "BatchPoolIdentity"
+ """The type of identity used for the Batch Pool."""
+ etag: str
+ """The ETag of the resource, used for concurrency statements."""
+ tags: dict[str, str]
+ """The tags of the resource."""
+
+
+class PoolEndpointConfiguration(TypedDict, total=False):
+ """The endpoint configuration for a pool.
+
+ :ivar inboundNatPools: A list of inbound NAT pools that can be used to address specific ports
+ on an individual compute node externally. Required.
+ :vartype inboundNatPools: list["InboundNatPool"]
+ """
+
+ inboundNatPools: Required[list["InboundNatPool"]]
+ """A list of inbound NAT pools that can be used to address specific ports on an individual compute
+ node externally. Required."""
+
+
+class PoolPatch(TypedDict, total=False):
+ """Properties supplied when updating a pool.
+
+ :ivar identity: The type of identity used for the Batch Pool.
+ :vartype identity: "BatchPoolIdentity"
+ :ivar etag: The ETag of the resource, used for concurrency statements.
+ :vartype etag: str
+ :ivar tags: The tags of the resource.
+ :vartype tags: dict[str, str]
+ :ivar id: Fully qualified resource ID for the resource. Ex -
+ /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
+ :vartype id: str
+ :ivar systemData: Azure Resource Manager metadata containing createdBy and modifiedBy
+ information.
+ :vartype systemData: "SystemData"
+ :ivar properties: The pool properties to update.
+ :vartype properties: "PoolPatchProperties"
+ """
+
+ identity: "BatchPoolIdentity"
+ """The type of identity used for the Batch Pool."""
+ etag: str
+ """The ETag of the resource, used for concurrency statements."""
+ tags: dict[str, str]
+ """The tags of the resource."""
+ id: str
+ """Fully qualified resource ID for the resource. Ex -
+ /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}."""
+ systemData: "SystemData"
+ """Azure Resource Manager metadata containing createdBy and modifiedBy information."""
+ properties: "PoolPatchProperties"
+ """The pool properties to update."""
+
+
+class PoolPatchProperties(TypedDict, total=False):
+ """Pool settings with partial updates for the new zone policies.
+
+ :ivar displayName: The display name for the pool.
+ :vartype displayName: str
+ :ivar lastModified: The last modified time of the pool.
+ :vartype lastModified: str
+ :ivar creationTime: The creation time of the pool.
+ :vartype creationTime: str
+ :ivar provisioningState: The current state of the pool. Known values are: "Succeeded" and
+ "Deleting".
+ :vartype provisioningState: Union[str, "PoolProvisioningState"]
+ :ivar provisioningStateTransitionTime: The time at which the pool entered its current state.
+ :vartype provisioningStateTransitionTime: str
+ :ivar allocationState: Whether the pool is resizing. Known values are: "Steady", "Resizing",
+ and "Stopping".
+ :vartype allocationState: Union[str, "AllocationState"]
+ :ivar allocationStateTransitionTime: The time at which the pool entered its current allocation
+ state.
+ :vartype allocationStateTransitionTime: str
+ :ivar vmSize: The size of virtual machines in the pool. All VMs in a pool are the same size.
+ :vartype vmSize: str
+ :ivar vmSkuProfile: Specifies the profile of VM sizes and the allocation strategy used to
+ allocate compute nodes for an Instance Mix pool. When specified, vmSize must be "Mix". This
+ property can only be changed while the pool has no compute nodes.
+ :vartype vmSkuProfile: "VirtualMachineSkuProfile"
+ :ivar currentDedicatedNodes: The number of dedicated compute nodes currently in the pool.
+ :vartype currentDedicatedNodes: int
+ :ivar currentLowPriorityNodes: The number of Spot/low-priority compute nodes currently in the
+ pool.
+ :vartype currentLowPriorityNodes: int
+ :ivar scaleSettings: Settings which configure the number of nodes in the pool.
+ :vartype scaleSettings: "ScaleSettings"
+ :ivar autoScaleRun: The results and errors from the last execution of the autoscale formula.
+ :vartype autoScaleRun: "AutoScaleRun"
+ :ivar interNodeCommunication: Whether the pool permits direct communication between nodes.
+ Known values are: "Enabled" and "Disabled".
+ :vartype interNodeCommunication: Union[str, "InterNodeCommunicationState"]
+ :ivar networkConfiguration: The network configuration for the pool.
+ :vartype networkConfiguration: "NetworkConfiguration"
+ :ivar taskSchedulingPolicy: How tasks are distributed across compute nodes in a pool.
+ :vartype taskSchedulingPolicy: "TaskSchedulingPolicy"
+ :ivar userAccounts: The list of user accounts to be created on each node in the pool.
+ :vartype userAccounts: list["UserAccount"]
+ :ivar metadata: A list of name-value pairs associated with the pool as metadata.
+ :vartype metadata: list["MetadataItem"]
+ :ivar startTask: A task specified to run on each compute node as it joins the pool.
+ :vartype startTask: "StartTask"
+ :ivar applicationPackages: The list of application packages to be installed on each compute
+ node in the pool.
+ :vartype applicationPackages: list["ApplicationPackageReference"]
+ :ivar resizeOperationStatus: Contains details about the current or last completed resize
+ operation.
+ :vartype resizeOperationStatus: "ResizeOperationStatus"
+ :ivar mountConfiguration: A list of file systems to mount on each node in the pool.
+ :vartype mountConfiguration: list["MountConfiguration"]
+ :ivar upgradePolicy: The upgrade policy for the pool.
+ :vartype upgradePolicy: "UpgradePolicy"
+ :ivar deploymentConfiguration: This property describes the virtual machines that the pool nodes
+ will be deployed on.
+ :vartype deploymentConfiguration: "DeploymentConfigurationPatch"
+ :ivar taskSlotsPerNode: The number of task slots that can be used to run concurrent tasks on a
+ single compute node in the pool.
+ :vartype taskSlotsPerNode: int
+ """
+
+ displayName: str
+ """The display name for the pool."""
+ lastModified: str
+ """The last modified time of the pool."""
+ creationTime: str
+ """The creation time of the pool."""
+ provisioningState: Union[str, "PoolProvisioningState"]
+ """The current state of the pool. Known values are: \"Succeeded\" and \"Deleting\"."""
+ provisioningStateTransitionTime: str
+ """The time at which the pool entered its current state."""
+ allocationState: Union[str, "AllocationState"]
+ """Whether the pool is resizing. Known values are: \"Steady\", \"Resizing\", and \"Stopping\"."""
+ allocationStateTransitionTime: str
+ """The time at which the pool entered its current allocation state."""
+ vmSize: str
+ """The size of virtual machines in the pool. All VMs in a pool are the same size."""
+ vmSkuProfile: "VirtualMachineSkuProfile"
+ """Specifies the profile of VM sizes and the allocation strategy used to allocate compute nodes
+ for an Instance Mix pool. When specified, vmSize must be \"Mix\". This property can only be
+ changed while the pool has no compute nodes."""
+ currentDedicatedNodes: int
+ """The number of dedicated compute nodes currently in the pool."""
+ currentLowPriorityNodes: int
+ """The number of Spot/low-priority compute nodes currently in the pool."""
+ scaleSettings: "ScaleSettings"
+ """Settings which configure the number of nodes in the pool."""
+ autoScaleRun: "AutoScaleRun"
+ """The results and errors from the last execution of the autoscale formula."""
+ interNodeCommunication: Union[str, "InterNodeCommunicationState"]
+ """Whether the pool permits direct communication between nodes. Known values are: \"Enabled\" and
+ \"Disabled\"."""
+ networkConfiguration: "NetworkConfiguration"
+ """The network configuration for the pool."""
+ taskSchedulingPolicy: "TaskSchedulingPolicy"
+ """How tasks are distributed across compute nodes in a pool."""
+ userAccounts: list["UserAccount"]
+ """The list of user accounts to be created on each node in the pool."""
+ metadata: list["MetadataItem"]
+ """A list of name-value pairs associated with the pool as metadata."""
+ startTask: "StartTask"
+ """A task specified to run on each compute node as it joins the pool."""
+ applicationPackages: list["ApplicationPackageReference"]
+ """The list of application packages to be installed on each compute node in the pool."""
+ resizeOperationStatus: "ResizeOperationStatus"
+ """Contains details about the current or last completed resize operation."""
+ mountConfiguration: list["MountConfiguration"]
+ """A list of file systems to mount on each node in the pool."""
+ upgradePolicy: "UpgradePolicy"
+ """The upgrade policy for the pool."""
+ deploymentConfiguration: "DeploymentConfigurationPatch"
+ """This property describes the virtual machines that the pool nodes will be deployed on."""
+ taskSlotsPerNode: int
+ """The number of task slots that can be used to run concurrent tasks on a single compute node in
+ the pool."""
+
+
+class PoolProperties(TypedDict, total=False):
+ """Pool properties.
+
+ :ivar displayName: The display name for the pool.
+ :vartype displayName: str
+ :ivar lastModified: The last modified time of the pool.
+ :vartype lastModified: str
+ :ivar creationTime: The creation time of the pool.
+ :vartype creationTime: str
+ :ivar provisioningState: The current state of the pool. Known values are: "Succeeded" and
+ "Deleting".
+ :vartype provisioningState: Union[str, "PoolProvisioningState"]
+ :ivar provisioningStateTransitionTime: The time at which the pool entered its current state.
+ :vartype provisioningStateTransitionTime: str
+ :ivar allocationState: Whether the pool is resizing. Known values are: "Steady", "Resizing",
+ and "Stopping".
+ :vartype allocationState: Union[str, "AllocationState"]
+ :ivar allocationStateTransitionTime: The time at which the pool entered its current allocation
+ state.
+ :vartype allocationStateTransitionTime: str
+ :ivar vmSize: The size of virtual machines in the pool. All VMs in a pool are the same size.
+ :vartype vmSize: str
+ :ivar vmSkuProfile: Specifies the profile of VM sizes and the allocation strategy used to
+ allocate compute nodes for an Instance Mix pool. When specified, vmSize must be "Mix". This
+ property can only be changed while the pool has no compute nodes.
+ :vartype vmSkuProfile: "VirtualMachineSkuProfile"
+ :ivar deploymentConfiguration: This property describes the virtual machines that the pool nodes
+ will be deployed on.
+ :vartype deploymentConfiguration: "DeploymentConfiguration"
+ :ivar currentDedicatedNodes: The number of dedicated compute nodes currently in the pool.
+ :vartype currentDedicatedNodes: int
+ :ivar currentLowPriorityNodes: The number of Spot/low-priority compute nodes currently in the
+ pool.
+ :vartype currentLowPriorityNodes: int
+ :ivar scaleSettings: Settings which configure the number of nodes in the pool.
+ :vartype scaleSettings: "ScaleSettings"
+ :ivar autoScaleRun: The results and errors from the last execution of the autoscale formula.
+ :vartype autoScaleRun: "AutoScaleRun"
+ :ivar interNodeCommunication: Whether the pool permits direct communication between nodes.
+ Known values are: "Enabled" and "Disabled".
+ :vartype interNodeCommunication: Union[str, "InterNodeCommunicationState"]
+ :ivar networkConfiguration: The network configuration for the pool.
+ :vartype networkConfiguration: "NetworkConfiguration"
+ :ivar taskSlotsPerNode: The number of task slots that can be used to run concurrent tasks on a
+ single compute node in the pool.
+ :vartype taskSlotsPerNode: int
+ :ivar taskSchedulingPolicy: How tasks are distributed across compute nodes in a pool.
+ :vartype taskSchedulingPolicy: "TaskSchedulingPolicy"
+ :ivar userAccounts: The list of user accounts to be created on each node in the pool.
+ :vartype userAccounts: list["UserAccount"]
+ :ivar metadata: A list of name-value pairs associated with the pool as metadata.
+ :vartype metadata: list["MetadataItem"]
+ :ivar startTask: A task specified to run on each compute node as it joins the pool.
+ :vartype startTask: "StartTask"
+ :ivar applicationPackages: The list of application packages to be installed on each compute
+ node in the pool.
+ :vartype applicationPackages: list["ApplicationPackageReference"]
+ :ivar resizeOperationStatus: Contains details about the current or last completed resize
+ operation.
+ :vartype resizeOperationStatus: "ResizeOperationStatus"
+ :ivar mountConfiguration: A list of file systems to mount on each node in the pool.
+ :vartype mountConfiguration: list["MountConfiguration"]
+ :ivar upgradePolicy: The upgrade policy for the pool.
+ :vartype upgradePolicy: "UpgradePolicy"
+ """
+
+ displayName: str
+ """The display name for the pool."""
+ lastModified: str
+ """The last modified time of the pool."""
+ creationTime: str
+ """The creation time of the pool."""
+ provisioningState: Union[str, "PoolProvisioningState"]
+ """The current state of the pool. Known values are: \"Succeeded\" and \"Deleting\"."""
+ provisioningStateTransitionTime: str
+ """The time at which the pool entered its current state."""
+ allocationState: Union[str, "AllocationState"]
+ """Whether the pool is resizing. Known values are: \"Steady\", \"Resizing\", and \"Stopping\"."""
+ allocationStateTransitionTime: str
+ """The time at which the pool entered its current allocation state."""
+ vmSize: str
+ """The size of virtual machines in the pool. All VMs in a pool are the same size."""
+ vmSkuProfile: "VirtualMachineSkuProfile"
+ """Specifies the profile of VM sizes and the allocation strategy used to allocate compute nodes
+ for an Instance Mix pool. When specified, vmSize must be \"Mix\". This property can only be
+ changed while the pool has no compute nodes."""
+ deploymentConfiguration: "DeploymentConfiguration"
+ """This property describes the virtual machines that the pool nodes will be deployed on."""
+ currentDedicatedNodes: int
+ """The number of dedicated compute nodes currently in the pool."""
+ currentLowPriorityNodes: int
+ """The number of Spot/low-priority compute nodes currently in the pool."""
+ scaleSettings: "ScaleSettings"
+ """Settings which configure the number of nodes in the pool."""
+ autoScaleRun: "AutoScaleRun"
+ """The results and errors from the last execution of the autoscale formula."""
+ interNodeCommunication: Union[str, "InterNodeCommunicationState"]
+ """Whether the pool permits direct communication between nodes. Known values are: \"Enabled\" and
+ \"Disabled\"."""
+ networkConfiguration: "NetworkConfiguration"
+ """The network configuration for the pool."""
+ taskSlotsPerNode: int
+ """The number of task slots that can be used to run concurrent tasks on a single compute node in
+ the pool."""
+ taskSchedulingPolicy: "TaskSchedulingPolicy"
+ """How tasks are distributed across compute nodes in a pool."""
+ userAccounts: list["UserAccount"]
+ """The list of user accounts to be created on each node in the pool."""
+ metadata: list["MetadataItem"]
+ """A list of name-value pairs associated with the pool as metadata."""
+ startTask: "StartTask"
+ """A task specified to run on each compute node as it joins the pool."""
+ applicationPackages: list["ApplicationPackageReference"]
+ """The list of application packages to be installed on each compute node in the pool."""
+ resizeOperationStatus: "ResizeOperationStatus"
+ """Contains details about the current or last completed resize operation."""
+ mountConfiguration: list["MountConfiguration"]
+ """A list of file systems to mount on each node in the pool."""
+ upgradePolicy: "UpgradePolicy"
+ """The upgrade policy for the pool."""
+
+
+class PrivateEndpoint(TypedDict, total=False):
+ """The private endpoint of the private endpoint connection.
+
+ :ivar id: The ARM resource identifier of the private endpoint. This is of the form
+ /subscriptions/{subscription}/resourceGroups/{group}/providers/Microsoft.Network/privateEndpoints/{privateEndpoint}.
+ :vartype id: str
+ """
+
+ id: str
+ """The ARM resource identifier of the private endpoint. This is of the form
+ /subscriptions/{subscription}/resourceGroups/{group}/providers/Microsoft.Network/privateEndpoints/{privateEndpoint}."""
+
+
+class PrivateEndpointConnection(ProxyResource):
+ """Contains information about a private link resource.
+
+ :ivar id: Fully qualified resource ID for the resource. Ex -
+ /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
+ :vartype id: str
+ :ivar name: The name of the resource.
+ :vartype name: str
+ :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
+ "Microsoft.Storage/storageAccounts".
+ :vartype type: str
+ :ivar systemData: Azure Resource Manager metadata containing createdBy and modifiedBy
+ information.
+ :vartype systemData: "SystemData"
+ :ivar properties: The properties associated with the private endpoint connection.
+ :vartype properties: "PrivateEndpointConnectionProperties"
+ :ivar etag: The ETag of the resource, used for concurrency statements.
+ :vartype etag: str
+ :ivar tags: The tags of the resource.
+ :vartype tags: dict[str, str]
+ """
+
+ properties: "PrivateEndpointConnectionProperties"
+ """The properties associated with the private endpoint connection."""
+ etag: str
+ """The ETag of the resource, used for concurrency statements."""
+ tags: dict[str, str]
+ """The tags of the resource."""
+
+
+class PrivateEndpointConnectionProperties(TypedDict, total=False):
+ """Private endpoint connection properties.
+
+ :ivar provisioningState: The provisioning state of the private endpoint connection. Known
+ values are: "Creating", "Updating", "Deleting", "Succeeded", "Failed", and "Cancelled".
+ :vartype provisioningState: Union[str, "PrivateEndpointConnectionProvisioningState"]
+ :ivar privateEndpoint: The ARM resource identifier of the private endpoint.
+ :vartype privateEndpoint: "PrivateEndpoint"
+ :ivar groupIds: The group id of the private endpoint connection.
+ :vartype groupIds: list[str]
+ :ivar privateLinkServiceConnectionState: The private link service connection state of the
+ private endpoint connection.
+ :vartype privateLinkServiceConnectionState: "PrivateLinkServiceConnectionState"
+ """
+
+ provisioningState: Union[str, "PrivateEndpointConnectionProvisioningState"]
+ """The provisioning state of the private endpoint connection. Known values are: \"Creating\",
+ \"Updating\", \"Deleting\", \"Succeeded\", \"Failed\", and \"Cancelled\"."""
+ privateEndpoint: "PrivateEndpoint"
+ """The ARM resource identifier of the private endpoint."""
+ groupIds: list[str]
+ """The group id of the private endpoint connection."""
+ privateLinkServiceConnectionState: "PrivateLinkServiceConnectionState"
+ """The private link service connection state of the private endpoint connection."""
+
+
+class PrivateLinkServiceConnectionState(TypedDict, total=False):
+ """The private link service connection state of the private endpoint connection.
+
+ :ivar status: The status of the Batch private endpoint connection. Required. Known values are:
+ "Approved", "Pending", "Rejected", and "Disconnected".
+ :vartype status: Union[str, "PrivateLinkServiceConnectionStatus"]
+ :ivar description: Description of the private Connection state.
+ :vartype description: str
+ :ivar actionsRequired: Action required on the private connection state.
+ :vartype actionsRequired: str
+ """
+
+ status: Required[Union[str, "PrivateLinkServiceConnectionStatus"]]
+ """The status of the Batch private endpoint connection. Required. Known values are: \"Approved\",
+ \"Pending\", \"Rejected\", and \"Disconnected\"."""
+ description: str
+ """Description of the private Connection state."""
+ actionsRequired: str
+ """Action required on the private connection state."""
+
+
+class ProxyAgentSettings(TypedDict, total=False):
+ """Specifies ProxyAgent settings while creating the virtual machine.
+
+ :ivar enabled: Specifies whether Metadata Security Protocol feature should be enabled on the
+ virtual machine or virtual machine scale set. Default is False.
+ :vartype enabled: bool
+ :ivar imds: Settings for the IMDS endpoint.
+ :vartype imds: "HostEndpointSettings"
+ :ivar wireServer: Settings for the WireServer endpoint.
+ :vartype wireServer: "HostEndpointSettings"
+ """
+
+ enabled: bool
+ """Specifies whether Metadata Security Protocol feature should be enabled on the virtual machine
+ or virtual machine scale set. Default is False."""
+ imds: "HostEndpointSettings"
+ """Settings for the IMDS endpoint."""
+ wireServer: "HostEndpointSettings"
+ """Settings for the WireServer endpoint."""
+
+
+class PublicIPAddressConfiguration(TypedDict, total=False):
+ """The public IP Address configuration of the networking configuration of a Pool.
+
+ :ivar provision: The provisioning type for Public IP Addresses for the Batch Pool. Known values
+ are: "BatchManaged", "UserManaged", and "NoPublicIPAddresses".
+ :vartype provision: Union[str, "IPAddressProvisioningType"]
+ :ivar ipAddressIds: The list of public IPs which the Batch service will use when provisioning
+ Compute Nodes.
+ :vartype ipAddressIds: list[str]
+ :ivar ipFamilies: The IP families used to specify IP versions available to the pool.
+ :vartype ipFamilies: list[Union[str, "IPFamily"]]
+ :ivar ipTags: IP Tags that will applied to new Public IPs that Batch creates.
+ :vartype ipTags: list["IPTag"]
+ """
+
+ provision: Union[str, "IPAddressProvisioningType"]
+ """The provisioning type for Public IP Addresses for the Batch Pool. Known values are:
+ \"BatchManaged\", \"UserManaged\", and \"NoPublicIPAddresses\"."""
+ ipAddressIds: list[str]
+ """The list of public IPs which the Batch service will use when provisioning Compute Nodes."""
+ ipFamilies: list[Union[str, "IPFamily"]]
+ """The IP families used to specify IP versions available to the pool."""
+ ipTags: list["IPTag"]
+ """IP Tags that will applied to new Public IPs that Batch creates."""
+
+
+class ResiliencyPolicy(TypedDict, total=False):
+ """The resiliency policy for compute nodes in a pool.
+
+ :ivar zoneAllocationPolicy: The policy that controls allocation across availability zones.
+ Required.
+ :vartype zoneAllocationPolicy: "ZoneAllocationPolicy"
+ """
+
+ zoneAllocationPolicy: Required["ZoneAllocationPolicy"]
+ """The policy that controls allocation across availability zones. Required."""
+
+
+class ResiliencyPolicyPatch(TypedDict, total=False):
+ """Resiliency policy fields to update, leaving omitted fields unchanged.
+
+ :ivar zoneAllocationPolicy: The zone allocation policy fields to update.
+ :vartype zoneAllocationPolicy: "ZoneAllocationPolicyPatch"
+ """
+
+ zoneAllocationPolicy: "ZoneAllocationPolicyPatch"
+ """The zone allocation policy fields to update."""
+
+
+class ResizeError(TypedDict, total=False):
+ """An error that occurred when resizing a pool.
+
+ :ivar code: An identifier for the error. Codes are invariant and are intended to be consumed
+ programmatically. Required.
+ :vartype code: str
+ :ivar message: A message describing the error, intended to be suitable for display in a user
+ interface. Required.
+ :vartype message: str
+ :ivar details: Additional details about the error.
+ :vartype details: list["ResizeError"]
+ """
+
+ code: Required[str]
+ """An identifier for the error. Codes are invariant and are intended to be consumed
+ programmatically. Required."""
+ message: Required[str]
+ """A message describing the error, intended to be suitable for display in a user interface.
+ Required."""
+ details: list["ResizeError"]
+ """Additional details about the error."""
+
+
+class ResizeOperationStatus(TypedDict, total=False):
+ """Details about the current or last completed resize operation.
+
+ :ivar targetDedicatedNodes: The desired number of dedicated compute nodes in the pool.
+ :vartype targetDedicatedNodes: int
+ :ivar targetLowPriorityNodes: The desired number of Spot/low-priority compute nodes in the
+ pool.
+ :vartype targetLowPriorityNodes: int
+ :ivar resizeTimeout: The timeout for allocation of compute nodes to the pool or removal of
+ compute nodes from the pool.
+ :vartype resizeTimeout: str
+ :ivar nodeDeallocationOption: Determines what to do with a node and its running task(s) after
+ it has been selected for deallocation. Known values are: "Requeue", "Terminate",
+ "TaskCompletion", and "RetainedData".
+ :vartype nodeDeallocationOption: Union[str, "ComputeNodeDeallocationOption"]
+ :ivar startTime: The time when this resize operation was started.
+ :vartype startTime: str
+ :ivar errors: Details of any errors encountered while performing the last resize on the pool.
+ :vartype errors: list["ResizeError"]
+ """
+
+ targetDedicatedNodes: int
+ """The desired number of dedicated compute nodes in the pool."""
+ targetLowPriorityNodes: int
+ """The desired number of Spot/low-priority compute nodes in the pool."""
+ resizeTimeout: str
+ """The timeout for allocation of compute nodes to the pool or removal of compute nodes from the
+ pool."""
+ nodeDeallocationOption: Union[str, "ComputeNodeDeallocationOption"]
+ """Determines what to do with a node and its running task(s) after it has been selected for
+ deallocation. Known values are: \"Requeue\", \"Terminate\", \"TaskCompletion\", and
+ \"RetainedData\"."""
+ startTime: str
+ """The time when this resize operation was started."""
+ errors: list["ResizeError"]
+ """Details of any errors encountered while performing the last resize on the pool."""
+
+
+class ResourceFile(TypedDict, total=False):
+ """A single file or multiple files to be downloaded to a compute node.
+
+ :ivar autoStorageContainerName: The storage container name in the auto storage account.
+ :vartype autoStorageContainerName: str
+ :ivar storageContainerUrl: The URL of the blob container within Azure Blob Storage.
+ :vartype storageContainerUrl: str
+ :ivar httpUrl: The URL of the file to download.
+ :vartype httpUrl: str
+ :ivar blobPrefix: The blob prefix to use when downloading blobs from an Azure Storage
+ container. Only the blobs whose names begin with the specified prefix will be downloaded.
+ :vartype blobPrefix: str
+ :ivar filePath: The location on the compute node to which to download the file, relative to the
+ task's working directory.
+ :vartype filePath: str
+ :ivar fileMode: The file permission mode attribute in octal format.
+ :vartype fileMode: str
+ :ivar identityReference: The reference to the user assigned identity to use to access Azure
+ Blob Storage specified by storageContainerUrl or httpUrl.
+ :vartype identityReference: "ComputeNodeIdentityReference"
+ """
+
+ autoStorageContainerName: str
+ """The storage container name in the auto storage account."""
+ storageContainerUrl: str
+ """The URL of the blob container within Azure Blob Storage."""
+ httpUrl: str
+ """The URL of the file to download."""
+ blobPrefix: str
+ """The blob prefix to use when downloading blobs from an Azure Storage container. Only the blobs
+ whose names begin with the specified prefix will be downloaded."""
+ filePath: str
+ """The location on the compute node to which to download the file, relative to the task's working
+ directory."""
+ fileMode: str
+ """The file permission mode attribute in octal format."""
+ identityReference: "ComputeNodeIdentityReference"
+ """The reference to the user assigned identity to use to access Azure Blob Storage specified by
+ storageContainerUrl or httpUrl."""
+
+
+class RollingUpgradePolicy(TypedDict, total=False):
+ """The configuration parameters used while performing a rolling upgrade.
+
+ :ivar enableCrossZoneUpgrade: Allow VMSS to ignore AZ boundaries when constructing upgrade
+ batches. Take into consideration the Update Domain and maxBatchInstancePercent to determine the
+ batch size. If this field is not set, Azure Azure Batch will not set its default value. The
+ value of enableCrossZoneUpgrade on the created VirtualMachineScaleSet will be decided by the
+ default configurations on VirtualMachineScaleSet. This field can be set to true or false only
+ when nodePlacementConfiguration.policy is Zonal or placement.zonePlacementPolicy is Auto.
+ :vartype enableCrossZoneUpgrade: bool
+ :ivar maxBatchInstancePercent: The maximum percent of total virtual machine instances that will
+ be upgraded simultaneously by the rolling upgrade in one batch. As this is a maximum, unhealthy
+ instances in previous or future batches can cause the percentage of instances in a batch to
+ decrease to ensure higher reliability. The value of this field should be between 5 and 100,
+ inclusive. If both maxBatchInstancePercent and maxUnhealthyInstancePercent are assigned with
+ value, the value of maxBatchInstancePercent should not be more than
+ maxUnhealthyInstancePercent.
+ :vartype maxBatchInstancePercent: int
+ :ivar maxUnhealthyInstancePercent: The maximum percentage of the total virtual machine
+ instances in the scale set that can be simultaneously unhealthy, either as a result of being
+ upgraded, or by being found in an unhealthy state by the virtual machine health checks before
+ the rolling upgrade aborts. This constraint will be checked prior to starting any batch. The
+ value of this field should be between 5 and 100, inclusive. If both maxBatchInstancePercent and
+ maxUnhealthyInstancePercent are assigned with value, the value of maxBatchInstancePercent
+ should not be more than maxUnhealthyInstancePercent.
+ :vartype maxUnhealthyInstancePercent: int
+ :ivar maxUnhealthyUpgradedInstancePercent: The maximum percentage of upgraded virtual machine
+ instances that can be found to be in an unhealthy state. This check will happen after each
+ batch is upgraded. If this percentage is ever exceeded, the rolling update aborts. The value of
+ this field should be between 0 and 100, inclusive.
+ :vartype maxUnhealthyUpgradedInstancePercent: int
+ :ivar pauseTimeBetweenBatches: The wait time between completing the update for all virtual
+ machines in one batch and starting the next batch. The time duration should be specified in ISO
+ 8601 format.
+ :vartype pauseTimeBetweenBatches: str
+ :ivar prioritizeUnhealthyInstances: Upgrade all unhealthy instances in a scale set before any
+ healthy instances.
+ :vartype prioritizeUnhealthyInstances: bool
+ :ivar rollbackFailedInstancesOnPolicyBreach: Rollback failed instances to previous model if the
+ Rolling Upgrade policy is violated.
+ :vartype rollbackFailedInstancesOnPolicyBreach: bool
+ """
+
+ enableCrossZoneUpgrade: bool
+ """Allow VMSS to ignore AZ boundaries when constructing upgrade batches. Take into consideration
+ the Update Domain and maxBatchInstancePercent to determine the batch size. If this field is not
+ set, Azure Azure Batch will not set its default value. The value of enableCrossZoneUpgrade on
+ the created VirtualMachineScaleSet will be decided by the default configurations on
+ VirtualMachineScaleSet. This field can be set to true or false only when
+ nodePlacementConfiguration.policy is Zonal or placement.zonePlacementPolicy is Auto."""
+ maxBatchInstancePercent: int
+ """The maximum percent of total virtual machine instances that will be upgraded simultaneously by
+ the rolling upgrade in one batch. As this is a maximum, unhealthy instances in previous or
+ future batches can cause the percentage of instances in a batch to decrease to ensure higher
+ reliability. The value of this field should be between 5 and 100, inclusive. If both
+ maxBatchInstancePercent and maxUnhealthyInstancePercent are assigned with value, the value of
+ maxBatchInstancePercent should not be more than maxUnhealthyInstancePercent."""
+ maxUnhealthyInstancePercent: int
+ """The maximum percentage of the total virtual machine instances in the scale set that can be
+ simultaneously unhealthy, either as a result of being upgraded, or by being found in an
+ unhealthy state by the virtual machine health checks before the rolling upgrade aborts. This
+ constraint will be checked prior to starting any batch. The value of this field should be
+ between 5 and 100, inclusive. If both maxBatchInstancePercent and maxUnhealthyInstancePercent
+ are assigned with value, the value of maxBatchInstancePercent should not be more than
+ maxUnhealthyInstancePercent."""
+ maxUnhealthyUpgradedInstancePercent: int
+ """The maximum percentage of upgraded virtual machine instances that can be found to be in an
+ unhealthy state. This check will happen after each batch is upgraded. If this percentage is
+ ever exceeded, the rolling update aborts. The value of this field should be between 0 and 100,
+ inclusive."""
+ pauseTimeBetweenBatches: str
+ """The wait time between completing the update for all virtual machines in one batch and starting
+ the next batch. The time duration should be specified in ISO 8601 format."""
+ prioritizeUnhealthyInstances: bool
+ """Upgrade all unhealthy instances in a scale set before any healthy instances."""
+ rollbackFailedInstancesOnPolicyBreach: bool
+ """Rollback failed instances to previous model if the Rolling Upgrade policy is violated."""
+
+
+class ScaleSettings(TypedDict, total=False):
+ """Scale settings for the pool.
+
+ :ivar fixedScale: Fixed scale settings for the pool.
+ :vartype fixedScale: "FixedScaleSettings"
+ :ivar autoScale: AutoScale settings for the pool.
+ :vartype autoScale: "AutoScaleSettings"
+ """
+
+ fixedScale: "FixedScaleSettings"
+ """Fixed scale settings for the pool."""
+ autoScale: "AutoScaleSettings"
+ """AutoScale settings for the pool."""
+
+
+class SecurityProfile(TypedDict, total=False):
+ """Specifies the security profile settings for the virtual machine or virtual machine scale set.
+
+ :ivar securityType: Specifies the SecurityType of the virtual machine. It has to be set to any
+ specified value to enable UefiSettings. Known values are: "trustedLaunch" and "confidentialVM".
+ :vartype securityType: Union[str, "SecurityTypes"]
+ :ivar encryptionAtHost: This property can be used by user in the request to enable or disable
+ the Host Encryption for the virtual machine or virtual machine scale set. This will enable the
+ encryption for all the disks including Resource/Temp disk at host itself.
+ :vartype encryptionAtHost: bool
+ :ivar uefiSettings: Specifies the security settings like secure boot and vTPM used while
+ creating the virtual machine.
+ :vartype uefiSettings: "UefiSettings"
+ :ivar proxyAgentSettings: Specifies ProxyAgent settings while creating the virtual machine.
+ :vartype proxyAgentSettings: "ProxyAgentSettings"
+ """
+
+ securityType: Union[str, "SecurityTypes"]
+ """Specifies the SecurityType of the virtual machine. It has to be set to any specified value to
+ enable UefiSettings. Known values are: \"trustedLaunch\" and \"confidentialVM\"."""
+ encryptionAtHost: bool
+ """This property can be used by user in the request to enable or disable the Host Encryption for
+ the virtual machine or virtual machine scale set. This will enable the encryption for all the
+ disks including Resource/Temp disk at host itself."""
+ uefiSettings: "UefiSettings"
+ """Specifies the security settings like secure boot and vTPM used while creating the virtual
+ machine."""
+ proxyAgentSettings: "ProxyAgentSettings"
+ """Specifies ProxyAgent settings while creating the virtual machine."""
+
+
+class ServiceArtifactReference(TypedDict, total=False):
+ """Specifies the service artifact reference id used to set same image version for all virtual
+ machines in the scale set when using 'latest' image version.
+
+ :ivar id: The service artifact reference id of ServiceArtifactReference. Required.
+ :vartype id: str
+ """
+
+ id: Required[str]
+ """The service artifact reference id of ServiceArtifactReference. Required."""
+
+
+class StartTask(TypedDict, total=False):
+ """A task which is run when a compute node joins a pool in the Azure Batch service, or when the
+ compute node is rebooted or reimaged.
+
+ :ivar commandLine: The command line of the start task.
+ :vartype commandLine: str
+ :ivar resourceFiles: A list of files that the Batch service will download to the compute node
+ before running the command line.
+ :vartype resourceFiles: list["ResourceFile"]
+ :ivar environmentSettings: A list of environment variable settings for the start task.
+ :vartype environmentSettings: list["EnvironmentSetting"]
+ :ivar userIdentity: The user identity under which the start task runs.
+ :vartype userIdentity: "UserIdentity"
+ :ivar maxTaskRetryCount: The maximum number of times the task may be retried.
+ :vartype maxTaskRetryCount: int
+ :ivar waitForSuccess: Whether the Batch service should wait for the start task to complete
+ successfully (that is, to exit with exit code 0) before scheduling any tasks on the compute
+ node.
+ :vartype waitForSuccess: bool
+ :ivar containerSettings: The settings for the container under which the start task runs.
+ :vartype containerSettings: "TaskContainerSettings"
+ """
+
+ commandLine: str
+ """The command line of the start task."""
+ resourceFiles: list["ResourceFile"]
+ """A list of files that the Batch service will download to the compute node before running the
+ command line."""
+ environmentSettings: list["EnvironmentSetting"]
+ """A list of environment variable settings for the start task."""
+ userIdentity: "UserIdentity"
+ """The user identity under which the start task runs."""
+ maxTaskRetryCount: int
+ """The maximum number of times the task may be retried."""
+ waitForSuccess: bool
+ """Whether the Batch service should wait for the start task to complete successfully (that is, to
+ exit with exit code 0) before scheduling any tasks on the compute node."""
+ containerSettings: "TaskContainerSettings"
+ """The settings for the container under which the start task runs."""
+
+
+class SystemData(TypedDict, total=False):
+ """Metadata pertaining to creation and last modification of the resource.
+
+ :ivar createdBy: The identity that created the resource.
+ :vartype createdBy: str
+ :ivar createdByType: The type of identity that created the resource. Known values are: "User",
+ "Application", "ManagedIdentity", and "Key".
+ :vartype createdByType: Union[str, "CreatedByType"]
+ :ivar createdAt: The timestamp of resource creation (UTC).
+ :vartype createdAt: str
+ :ivar lastModifiedBy: The identity that last modified the resource.
+ :vartype lastModifiedBy: str
+ :ivar lastModifiedByType: The type of identity that last modified the resource. Known values
+ are: "User", "Application", "ManagedIdentity", and "Key".
+ :vartype lastModifiedByType: Union[str, "CreatedByType"]
+ :ivar lastModifiedAt: The timestamp of resource last modification (UTC).
+ :vartype lastModifiedAt: str
+ """
+
+ createdBy: str
+ """The identity that created the resource."""
+ createdByType: Union[str, "CreatedByType"]
+ """The type of identity that created the resource. Known values are: \"User\", \"Application\",
+ \"ManagedIdentity\", and \"Key\"."""
+ createdAt: str
+ """The timestamp of resource creation (UTC)."""
+ lastModifiedBy: str
+ """The identity that last modified the resource."""
+ lastModifiedByType: Union[str, "CreatedByType"]
+ """The type of identity that last modified the resource. Known values are: \"User\",
+ \"Application\", \"ManagedIdentity\", and \"Key\"."""
+ lastModifiedAt: str
+ """The timestamp of resource last modification (UTC)."""
+
+
+class TaskContainerSettings(TypedDict, total=False):
+ """The container settings for a task.
+
+ :ivar containerRunOptions: Additional options to the container create command.
+ :vartype containerRunOptions: str
+ :ivar imageName: The image to use to create the container in which the task will run. Required.
+ :vartype imageName: str
+ :ivar registry: The private registry which contains the container image.
+ :vartype registry: "ContainerRegistry"
+ :ivar workingDirectory: A flag to indicate where the container task working directory is. The
+ default is 'taskWorkingDirectory'. Known values are: "TaskWorkingDirectory" and
+ "ContainerImageDefault".
+ :vartype workingDirectory: Union[str, "ContainerWorkingDirectory"]
+ :ivar containerHostBatchBindMounts: The paths you want to mounted to container task.
+ :vartype containerHostBatchBindMounts: list["ContainerHostBatchBindMountEntry"]
+ """
+
+ containerRunOptions: str
+ """Additional options to the container create command."""
+ imageName: Required[str]
+ """The image to use to create the container in which the task will run. Required."""
+ registry: "ContainerRegistry"
+ """The private registry which contains the container image."""
+ workingDirectory: Union[str, "ContainerWorkingDirectory"]
+ """A flag to indicate where the container task working directory is. The default is
+ 'taskWorkingDirectory'. Known values are: \"TaskWorkingDirectory\" and
+ \"ContainerImageDefault\"."""
+ containerHostBatchBindMounts: list["ContainerHostBatchBindMountEntry"]
+ """The paths you want to mounted to container task."""
+
+
+class TaskSchedulingPolicy(TypedDict, total=False):
+ """Specifies how tasks should be distributed across compute nodes.
+
+ :ivar jobDefaultOrder: If not specified, the default is none. Known values are: "None" and
+ "CreationTime".
+ :vartype jobDefaultOrder: Union[str, "JobDefaultOrder"]
+ :ivar nodeFillType: How tasks should be distributed across compute nodes. Required. Known
+ values are: "Spread" and "Pack".
+ :vartype nodeFillType: Union[str, "ComputeNodeFillType"]
+ """
+
+ jobDefaultOrder: Union[str, "JobDefaultOrder"]
+ """If not specified, the default is none. Known values are: \"None\" and \"CreationTime\"."""
+ nodeFillType: Required[Union[str, "ComputeNodeFillType"]]
+ """How tasks should be distributed across compute nodes. Required. Known values are: \"Spread\"
+ and \"Pack\"."""
+
+
+class UefiSettings(TypedDict, total=False):
+ """Specifies the security settings like secure boot and vTPM used while creating the virtual
+ machine.
+
+ :ivar secureBootEnabled: Specifies whether secure boot should be enabled on the virtual
+ machine.
+ :vartype secureBootEnabled: bool
+ :ivar vTpmEnabled: Specifies whether vTPM should be enabled on the virtual machine.
+ :vartype vTpmEnabled: bool
+ """
+
+ secureBootEnabled: bool
+ """Specifies whether secure boot should be enabled on the virtual machine."""
+ vTpmEnabled: bool
+ """Specifies whether vTPM should be enabled on the virtual machine."""
+
+
+class UpgradePolicy(TypedDict, total=False):
+ """Describes an upgrade policy - automatic, manual, or rolling.
+
+ :ivar mode: Specifies the mode of an upgrade to virtual machines in the scale set.
+ Possible values are:
**Manual** - You control the application of updates to
+ virtual machines in the scale set. You do this by using the manualUpgrade action.
+ **Automatic** - All virtual machines in the scale set are automatically updated at the same
+ time.
**Rolling** - Scale set performs updates in batches with an optional pause
+ time in between. Required. Known values are: "automatic", "manual", and "rolling".
+ :vartype mode: Union[str, "UpgradeMode"]
+ :ivar automaticOSUpgradePolicy: Configuration parameters used for performing automatic OS
+ Upgrade.
+ :vartype automaticOSUpgradePolicy: "AutomaticOSUpgradePolicy"
+ :ivar rollingUpgradePolicy: The configuration parameters used while performing a rolling
+ upgrade.
+ :vartype rollingUpgradePolicy: "RollingUpgradePolicy"
+ """
+
+ mode: Required[Union[str, "UpgradeMode"]]
+ """Specifies the mode of an upgrade to virtual machines in the scale set.
Possible
+ values are:
**Manual** - You control the application of updates to virtual
+ machines in the scale set. You do this by using the manualUpgrade action.
+ **Automatic** - All virtual machines in the scale set are automatically updated at the same
+ time.
**Rolling** - Scale set performs updates in batches with an optional pause
+ time in between. Required. Known values are: \"automatic\", \"manual\", and \"rolling\"."""
+ automaticOSUpgradePolicy: "AutomaticOSUpgradePolicy"
+ """Configuration parameters used for performing automatic OS Upgrade."""
+ rollingUpgradePolicy: "RollingUpgradePolicy"
+ """The configuration parameters used while performing a rolling upgrade."""
+
+
+class UserAccount(TypedDict, total=False):
+ """Properties used to create a user on an Azure Batch node.
+
+ :ivar name: The name of the user account. Names can contain any Unicode characters up to a
+ maximum length of 20. Required.
+ :vartype name: str
+ :ivar password: The password for the user account. Required.
+ :vartype password: str
+ :ivar elevationLevel: The elevation level of the user. Known values are: "NonAdmin" and
+ "Admin".
+ :vartype elevationLevel: Union[str, "ElevationLevel"]
+ :ivar linuxUserConfiguration: The Linux-specific user configuration for the user account.
+ :vartype linuxUserConfiguration: "LinuxUserConfiguration"
+ :ivar windowsUserConfiguration: The Windows-specific user configuration for the user account.
+ :vartype windowsUserConfiguration: "WindowsUserConfiguration"
+ """
+
+ name: Required[str]
+ """The name of the user account. Names can contain any Unicode characters up to a maximum length
+ of 20. Required."""
+ password: Required[str]
+ """The password for the user account. Required."""
+ elevationLevel: Union[str, "ElevationLevel"]
+ """The elevation level of the user. Known values are: \"NonAdmin\" and \"Admin\"."""
+ linuxUserConfiguration: "LinuxUserConfiguration"
+ """The Linux-specific user configuration for the user account."""
+ windowsUserConfiguration: "WindowsUserConfiguration"
+ """The Windows-specific user configuration for the user account."""
+
+
+class UserAssignedIdentities(TypedDict, total=False):
+ """The list of associated user identities.
+
+ :ivar principalId: The principal id of user assigned identity.
+ :vartype principalId: str
+ :ivar clientId: The client id of user assigned identity.
+ :vartype clientId: str
+ """
+
+ principalId: str
+ """The principal id of user assigned identity."""
+ clientId: str
+ """The client id of user assigned identity."""
+
+
+class UserIdentity(TypedDict, total=False):
+ """The definition of the user identity under which the task is run.
+
+ :ivar userName: The name of the user identity under which the task is run.
+ :vartype userName: str
+ :ivar autoUser: The auto user under which the task is run.
+ :vartype autoUser: "AutoUserSpecification"
+ """
+
+ userName: str
+ """The name of the user identity under which the task is run."""
+ autoUser: "AutoUserSpecification"
+ """The auto user under which the task is run."""
+
+
+class VirtualMachineConfiguration(TypedDict, total=False):
+ """The configuration for compute nodes in a pool based on the Azure Virtual Machines
+ infrastructure.
+
+ :ivar imageReference: A reference to the Azure Virtual Machines Marketplace Image or the custom
+ Virtual Machine Image to use. Required.
+ :vartype imageReference: "ImageReference"
+ :ivar nodeAgentSkuId: The SKU of the Batch node agent to be provisioned on compute nodes in the
+ pool. Required.
+ :vartype nodeAgentSkuId: str
+ :ivar windowsConfiguration: Windows operating system settings on the virtual machine.
+ :vartype windowsConfiguration: "WindowsConfiguration"
+ :ivar dataDisks: The configuration for data disks attached to the compute nodes in the pool.
+ :vartype dataDisks: list["DataDisk"]
+ :ivar licenseType: The type of on-premises license to be used when deploying the operating
+ system.
+ :vartype licenseType: str
+ :ivar containerConfiguration: The container configuration for the pool.
+ :vartype containerConfiguration: "ContainerConfiguration"
+ :ivar diskEncryptionConfiguration: The disk encryption configuration for the pool.
+ :vartype diskEncryptionConfiguration: "DiskEncryptionConfiguration"
+ :ivar nodePlacementConfiguration: The node placement configuration for the pool.
+ :vartype nodePlacementConfiguration: "NodePlacementConfiguration"
+ :ivar extensions: The virtual machine extension for the pool.
+ :vartype extensions: list["VMExtension"]
+ :ivar osDisk: Settings for the operating system disk of the Virtual Machine.
+ :vartype osDisk: "OSDisk"
+ :ivar securityProfile: Specifies the security profile settings for the virtual machine or
+ virtual machine scale set.
+ :vartype securityProfile: "SecurityProfile"
+ :ivar serviceArtifactReference: Specifies the service artifact reference id used to set same
+ image version for all virtual machines in the scale set when using 'latest' image version.
+ :vartype serviceArtifactReference: "ServiceArtifactReference"
+ :ivar hardwareProfile: Specifies the hardware settings for the compute nodes.
+ :vartype hardwareProfile: "HardwareProfile"
+ :ivar placement: The availability zone placement policy for compute nodes in the pool.
+ :vartype placement: "Placement"
+ :ivar resiliencyPolicy: The resiliency policy for compute nodes in the pool.
+ :vartype resiliencyPolicy: "ResiliencyPolicy"
+ """
+
+ imageReference: Required["ImageReference"]
+ """A reference to the Azure Virtual Machines Marketplace Image or the custom Virtual Machine Image
+ to use. Required."""
+ nodeAgentSkuId: Required[str]
+ """The SKU of the Batch node agent to be provisioned on compute nodes in the pool. Required."""
+ windowsConfiguration: "WindowsConfiguration"
+ """Windows operating system settings on the virtual machine."""
+ dataDisks: list["DataDisk"]
+ """The configuration for data disks attached to the compute nodes in the pool."""
+ licenseType: str
+ """The type of on-premises license to be used when deploying the operating system."""
+ containerConfiguration: "ContainerConfiguration"
+ """The container configuration for the pool."""
+ diskEncryptionConfiguration: "DiskEncryptionConfiguration"
+ """The disk encryption configuration for the pool."""
+ nodePlacementConfiguration: "NodePlacementConfiguration"
+ """The node placement configuration for the pool."""
+ extensions: list["VMExtension"]
+ """The virtual machine extension for the pool."""
+ osDisk: "OSDisk"
+ """Settings for the operating system disk of the Virtual Machine."""
+ securityProfile: "SecurityProfile"
+ """Specifies the security profile settings for the virtual machine or virtual machine scale set."""
+ serviceArtifactReference: "ServiceArtifactReference"
+ """Specifies the service artifact reference id used to set same image version for all virtual
+ machines in the scale set when using 'latest' image version."""
+ hardwareProfile: "HardwareProfile"
+ """Specifies the hardware settings for the compute nodes."""
+ placement: "Placement"
+ """The availability zone placement policy for compute nodes in the pool."""
+ resiliencyPolicy: "ResiliencyPolicy"
+ """The resiliency policy for compute nodes in the pool."""
+
+
+class VirtualMachineConfigurationPatch(TypedDict, total=False):
+ """Virtual machine settings retaining legacy requirements when updating zone policies.
+
+ :ivar imageReference: A reference to the Azure Virtual Machines Marketplace Image or the custom
+ Virtual Machine Image to use. Required.
+ :vartype imageReference: "ImageReference"
+ :ivar nodeAgentSkuId: The SKU of the Batch node agent to be provisioned on compute nodes in the
+ pool. Required.
+ :vartype nodeAgentSkuId: str
+ :ivar windowsConfiguration: Windows operating system settings on the virtual machine.
+ :vartype windowsConfiguration: "WindowsConfiguration"
+ :ivar dataDisks: The configuration for data disks attached to the compute nodes in the pool.
+ :vartype dataDisks: list["DataDisk"]
+ :ivar licenseType: The type of on-premises license to be used when deploying the operating
+ system.
+ :vartype licenseType: str
+ :ivar containerConfiguration: The container configuration for the pool.
+ :vartype containerConfiguration: "ContainerConfiguration"
+ :ivar diskEncryptionConfiguration: The disk encryption configuration for the pool.
+ :vartype diskEncryptionConfiguration: "DiskEncryptionConfiguration"
+ :ivar nodePlacementConfiguration: The node placement configuration for the pool.
+ :vartype nodePlacementConfiguration: "NodePlacementConfiguration"
+ :ivar extensions: The virtual machine extension for the pool.
+ :vartype extensions: list["VMExtension"]
+ :ivar osDisk: Settings for the operating system disk of the Virtual Machine.
+ :vartype osDisk: "OSDisk"
+ :ivar securityProfile: Specifies the security profile settings for the virtual machine or
+ virtual machine scale set.
+ :vartype securityProfile: "SecurityProfile"
+ :ivar serviceArtifactReference: Specifies the service artifact reference id used to set same
+ image version for all virtual machines in the scale set when using 'latest' image version.
+ :vartype serviceArtifactReference: "ServiceArtifactReference"
+ :ivar hardwareProfile: Specifies the hardware settings for the compute nodes.
+ :vartype hardwareProfile: "HardwareProfile"
+ :ivar placement: The availability zone placement policy to update. Omitted fields retain their
+ existing values.
+ :vartype placement: "PlacementPatch"
+ :ivar resiliencyPolicy: The resiliency policy to update. Omitted fields retain their existing
+ values.
+ :vartype resiliencyPolicy: "ResiliencyPolicyPatch"
+ """
+
+ imageReference: Required["ImageReference"]
+ """A reference to the Azure Virtual Machines Marketplace Image or the custom Virtual Machine Image
+ to use. Required."""
+ nodeAgentSkuId: Required[str]
+ """The SKU of the Batch node agent to be provisioned on compute nodes in the pool. Required."""
+ windowsConfiguration: "WindowsConfiguration"
+ """Windows operating system settings on the virtual machine."""
+ dataDisks: list["DataDisk"]
+ """The configuration for data disks attached to the compute nodes in the pool."""
+ licenseType: str
+ """The type of on-premises license to be used when deploying the operating system."""
+ containerConfiguration: "ContainerConfiguration"
+ """The container configuration for the pool."""
+ diskEncryptionConfiguration: "DiskEncryptionConfiguration"
+ """The disk encryption configuration for the pool."""
+ nodePlacementConfiguration: "NodePlacementConfiguration"
+ """The node placement configuration for the pool."""
+ extensions: list["VMExtension"]
+ """The virtual machine extension for the pool."""
+ osDisk: "OSDisk"
+ """Settings for the operating system disk of the Virtual Machine."""
+ securityProfile: "SecurityProfile"
+ """Specifies the security profile settings for the virtual machine or virtual machine scale set."""
+ serviceArtifactReference: "ServiceArtifactReference"
+ """Specifies the service artifact reference id used to set same image version for all virtual
+ machines in the scale set when using 'latest' image version."""
+ hardwareProfile: "HardwareProfile"
+ """Specifies the hardware settings for the compute nodes."""
+ placement: "PlacementPatch"
+ """The availability zone placement policy to update. Omitted fields retain their existing values."""
+ resiliencyPolicy: "ResiliencyPolicyPatch"
+ """The resiliency policy to update. Omitted fields retain their existing values."""
+
+
+class VirtualMachineSkuProfile(TypedDict, total=False):
+ """Specifies the set of VM sizes and the allocation strategy used to allocate compute nodes for an
+ Instance Mix pool.
+
+ :ivar vmSizes: The list of VM sizes (up to 5) that may be allocated for the Pool. VM sizes may
+ span the supported A, B, D, E, and F VM families, but must have the same vCPU count and CPU
+ architecture and compatible VM capabilities. This must be specified when the vmSkuProfile is
+ provided during Pool creation.
+ :vartype vmSizes: list["VirtualMachineSkuProfileVmSize"]
+ :ivar allocationStrategy: The allocation strategy used to select VM sizes from vmSizes.
+ Defaults to LowestPrice when not specified. Known values are: "LowestPrice",
+ "CapacityOptimized", and "Prioritized".
+ :vartype allocationStrategy: Union[str, "VirtualMachineSkuAllocationStrategy"]
+ """
+
+ vmSizes: list["VirtualMachineSkuProfileVmSize"]
+ """The list of VM sizes (up to 5) that may be allocated for the Pool. VM sizes may span the
+ supported A, B, D, E, and F VM families, but must have the same vCPU count and CPU architecture
+ and compatible VM capabilities. This must be specified when the vmSkuProfile is provided during
+ Pool creation."""
+ allocationStrategy: Union[str, "VirtualMachineSkuAllocationStrategy"]
+ """The allocation strategy used to select VM sizes from vmSizes. Defaults to LowestPrice when not
+ specified. Known values are: \"LowestPrice\", \"CapacityOptimized\", and \"Prioritized\"."""
+
+
+class VirtualMachineSkuProfileVmSize(TypedDict, total=False):
+ """Specifies a single VM size that may be allocated for an Instance Mix pool.
+
+ :ivar name: The name of the VM size (for example, "Standard_D8s_v5"). Required.
+ :vartype name: str
+ :ivar rank: The 0-based rank (a.k.a. priority) associated with this VM size. Lower values
+ indicate higher priority. Rank is required only when the allocation strategy is 'Prioritized'
+ and must be omitted otherwise.
+ :vartype rank: int
+ """
+
+ name: Required[str]
+ """The name of the VM size (for example, \"Standard_D8s_v5\"). Required."""
+ rank: int
+ """The 0-based rank (a.k.a. priority) associated with this VM size. Lower values indicate higher
+ priority. Rank is required only when the allocation strategy is 'Prioritized' and must be
+ omitted otherwise."""
+
+
+class VMDiskSecurityProfile(TypedDict, total=False):
+ """Specifies the security profile settings for the managed disk. **Note**: It can only be set for
+ Confidential VMs and is required when using Confidential VMs.
+
+ :ivar securityEncryptionType: Specifies the EncryptionType of the managed disk. It is set to
+ VMGuestStateOnly for encryption of just the VMGuestState blob, and NonPersistedTPM for not
+ persisting firmware state in the VMGuestState blob. **Note**: It can be set for only
+ Confidential VMs and required when using Confidential VMs. Known values are: "NonPersistedTPM",
+ "VMGuestStateOnly", and "DiskWithVMGuestState".
+ :vartype securityEncryptionType: Union[str, "SecurityEncryptionTypes"]
+ :ivar diskEncryptionSet: Specifies the customer managed disk encryption set resource id for the
+ managed disk that is used for Customer Managed Key encrypted ConfidentialVM OS Disk and VMGuest
+ blob. It can be set only in UserSubscription mode.
+ :vartype diskEncryptionSet: "DiskEncryptionSetParameters"
+ """
+
+ securityEncryptionType: Union[str, "SecurityEncryptionTypes"]
+ """Specifies the EncryptionType of the managed disk. It is set to VMGuestStateOnly for encryption
+ of just the VMGuestState blob, and NonPersistedTPM for not persisting firmware state in the
+ VMGuestState blob. **Note**: It can be set for only Confidential VMs and required when using
+ Confidential VMs. Known values are: \"NonPersistedTPM\", \"VMGuestStateOnly\", and
+ \"DiskWithVMGuestState\"."""
+ diskEncryptionSet: "DiskEncryptionSetParameters"
+ """Specifies the customer managed disk encryption set resource id for the managed disk that is
+ used for Customer Managed Key encrypted ConfidentialVM OS Disk and VMGuest blob. It can be set
+ only in UserSubscription mode."""
+
+
+class VMExtension(TypedDict, total=False):
+ """The configuration for virtual machine extensions.
+
+ :ivar name: The name of the virtual machine extension. Required.
+ :vartype name: str
+ :ivar publisher: The name of the extension handler publisher. Required.
+ :vartype publisher: str
+ :ivar type: The type of the extensions. Required.
+ :vartype type: str
+ :ivar typeHandlerVersion: The version of script handler.
+ :vartype typeHandlerVersion: str
+ :ivar autoUpgradeMinorVersion: Indicates whether the extension should use a newer minor version
+ if one is available at deployment time. Once deployed, however, the extension will not upgrade
+ minor versions unless redeployed, even with this property set to true.
+ :vartype autoUpgradeMinorVersion: bool
+ :ivar enableAutomaticUpgrade: Indicates whether the extension should be automatically upgraded
+ by the platform if there is a newer version of the extension available.
+ :vartype enableAutomaticUpgrade: bool
+ :ivar settings: JSON formatted public settings for the extension.
+ :vartype settings: Any
+ :ivar protectedSettings: The extension can contain either protectedSettings or
+ protectedSettingsFromKeyVault or no protected settings at all.
+ :vartype protectedSettings: Any
+ :ivar provisionAfterExtensions: The collection of extension names.
+ :vartype provisionAfterExtensions: list[str]
+ """
+
+ name: Required[str]
+ """The name of the virtual machine extension. Required."""
+ publisher: Required[str]
+ """The name of the extension handler publisher. Required."""
+ type: Required[str]
+ """The type of the extensions. Required."""
+ typeHandlerVersion: str
+ """The version of script handler."""
+ autoUpgradeMinorVersion: bool
+ """Indicates whether the extension should use a newer minor version if one is available at
+ deployment time. Once deployed, however, the extension will not upgrade minor versions unless
+ redeployed, even with this property set to true."""
+ enableAutomaticUpgrade: bool
+ """Indicates whether the extension should be automatically upgraded by the platform if there is a
+ newer version of the extension available."""
+ settings: Any
+ """JSON formatted public settings for the extension."""
+ protectedSettings: Any
+ """The extension can contain either protectedSettings or protectedSettingsFromKeyVault or no
+ protected settings at all."""
+ provisionAfterExtensions: list[str]
+ """The collection of extension names."""
+
+
+class VmSizeProperties(TypedDict, total=False):
+ """Specifies the properties for customizing the size of the virtual machine.
+
+ :ivar vCPUsAvailable: Specifies the number of vCPUs available for the VM. When this property is
+ not specified in the request body the default behavior is to set it to the value of vCPUs
+ available for that VM size.
+ :vartype vCPUsAvailable: int
+ :ivar vCPUsPerCore: Specifies the vCPU to physical core ratio. When this property is not
+ specified in the request body the default behavior is set to the value of vCPUsPerCore for the
+ VM Size. **Setting this property to 1 also means that hyper-threading is disabled.**.
+ :vartype vCPUsPerCore: int
+ """
+
+ vCPUsAvailable: int
+ """Specifies the number of vCPUs available for the VM. When this property is not specified in the
+ request body the default behavior is to set it to the value of vCPUs available for that VM
+ size."""
+ vCPUsPerCore: int
+ """Specifies the vCPU to physical core ratio. When this property is not specified in the request
+ body the default behavior is set to the value of vCPUsPerCore for the VM Size. **Setting this
+ property to 1 also means that hyper-threading is disabled.**."""
+
+
+class WindowsConfiguration(TypedDict, total=False):
+ """Windows operating system settings to apply to the virtual machine.
+
+ :ivar enableAutomaticUpdates: Whether automatic updates are enabled on the virtual machine.
+ :vartype enableAutomaticUpdates: bool
+ """
+
+ enableAutomaticUpdates: bool
+ """Whether automatic updates are enabled on the virtual machine."""
+
+
+class WindowsUserConfiguration(TypedDict, total=False):
+ """Properties used to create a user account on a Windows node.
+
+ :ivar loginMode: Login mode for user. Known values are: "Batch" and "Interactive".
+ :vartype loginMode: Union[str, "LoginMode"]
+ """
+
+ loginMode: Union[str, "LoginMode"]
+ """Login mode for user. Known values are: \"Batch\" and \"Interactive\"."""
+
+
+class ZoneAllocationPolicy(TypedDict, total=False):
+ """The policy that controls allocation across availability zones.
+
+ :ivar maxZoneCount: The maximum number of availability zones that may be used. The value cannot
+ exceed the number of zones supported by the region.
+ :vartype maxZoneCount: int
+ :ivar maxInstancePercentPerZonePolicy: The policy that limits the percentage of pool instances
+ that may be allocated in a single availability zone.
+ :vartype maxInstancePercentPerZonePolicy: "MaxInstancePercentPerZonePolicy"
+ """
+
+ maxZoneCount: int
+ """The maximum number of availability zones that may be used. The value cannot exceed the number
+ of zones supported by the region."""
+ maxInstancePercentPerZonePolicy: "MaxInstancePercentPerZonePolicy"
+ """The policy that limits the percentage of pool instances that may be allocated in a single
+ availability zone."""
+
+
+class ZoneAllocationPolicyPatch(TypedDict, total=False):
+ """Zone allocation policy fields to update, leaving omitted fields unchanged.
+
+ :ivar maxZoneCount: The maximum number of availability zones that may be used. The value cannot
+ exceed the number of zones supported by the region.
+ :vartype maxZoneCount: int
+ :ivar maxInstancePercentPerZonePolicy: The per-zone instance percentage policy fields to
+ update.
+ :vartype maxInstancePercentPerZonePolicy: "MaxInstancePercentPerZonePolicyPatch"
+ """
+
+ maxZoneCount: int
+ """The maximum number of availability zones that may be used. The value cannot exceed the number
+ of zones supported by the region."""
+ maxInstancePercentPerZonePolicy: "MaxInstancePercentPerZonePolicyPatch"
+ """The per-zone instance percentage policy fields to update."""
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/application_create.py b/sdk/batch/azure-mgmt-batch/generated_samples/application_create.py
index 455a3af88c56..2ca72b105d91 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/application_create.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/application_create.py
@@ -38,6 +38,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/ApplicationCreate.json
+# x-ms-original-file: 2026-10-01/ApplicationCreate.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/application_delete.py b/sdk/batch/azure-mgmt-batch/generated_samples/application_delete.py
index 5ed63f9eacc2..f6f7ee1900cb 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/application_delete.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/application_delete.py
@@ -37,6 +37,6 @@ def main():
)
-# x-ms-original-file: 2025-06-01/ApplicationDelete.json
+# x-ms-original-file: 2026-10-01/ApplicationDelete.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/application_get.py b/sdk/batch/azure-mgmt-batch/generated_samples/application_get.py
index 4f746731faa0..b0bd58aa5a0f 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/application_get.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/application_get.py
@@ -38,6 +38,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/ApplicationGet.json
+# x-ms-original-file: 2026-10-01/ApplicationGet.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/application_list.py b/sdk/batch/azure-mgmt-batch/generated_samples/application_list.py
index 8a8be7c3806b..75697083aa14 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/application_list.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/application_list.py
@@ -38,6 +38,6 @@ def main():
print(item)
-# x-ms-original-file: 2025-06-01/ApplicationList.json
+# x-ms-original-file: 2026-10-01/ApplicationList.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/application_package_activate.py b/sdk/batch/azure-mgmt-batch/generated_samples/application_package_activate.py
index 4068ba1030df..c508abadae5d 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/application_package_activate.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/application_package_activate.py
@@ -40,6 +40,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/ApplicationPackageActivate.json
+# x-ms-original-file: 2026-10-01/ApplicationPackageActivate.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/application_package_create.py b/sdk/batch/azure-mgmt-batch/generated_samples/application_package_create.py
index 2544eddbc7a1..d04913168714 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/application_package_create.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/application_package_create.py
@@ -39,6 +39,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/ApplicationPackageCreate.json
+# x-ms-original-file: 2026-10-01/ApplicationPackageCreate.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/application_package_delete.py b/sdk/batch/azure-mgmt-batch/generated_samples/application_package_delete.py
index 8a583591f46d..e5392e3470db 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/application_package_delete.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/application_package_delete.py
@@ -38,6 +38,6 @@ def main():
)
-# x-ms-original-file: 2025-06-01/ApplicationPackageDelete.json
+# x-ms-original-file: 2026-10-01/ApplicationPackageDelete.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/application_package_get.py b/sdk/batch/azure-mgmt-batch/generated_samples/application_package_get.py
index 8a4125c491bd..a287c609cdd7 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/application_package_get.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/application_package_get.py
@@ -39,6 +39,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/ApplicationPackageGet.json
+# x-ms-original-file: 2026-10-01/ApplicationPackageGet.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/application_package_list.py b/sdk/batch/azure-mgmt-batch/generated_samples/application_package_list.py
index 0e3f659050b0..2d0c443a035f 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/application_package_list.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/application_package_list.py
@@ -39,6 +39,6 @@ def main():
print(item)
-# x-ms-original-file: 2025-06-01/ApplicationPackageList.json
+# x-ms-original-file: 2026-10-01/ApplicationPackageList.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/application_update.py b/sdk/batch/azure-mgmt-batch/generated_samples/application_update.py
index a199ea862f92..a5bbb2bd1c8d 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/application_update.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/application_update.py
@@ -39,6 +39,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/ApplicationUpdate.json
+# x-ms-original-file: 2026-10-01/ApplicationUpdate.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_byos.py b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_byos.py
index 7bda8ec77ef0..0da61a15d588 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_byos.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_byos.py
@@ -51,6 +51,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/BatchAccountCreate_BYOS.json
+# x-ms-original-file: 2026-10-01/BatchAccountCreate_BYOS.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_default.py b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_default.py
index b85c570d9281..24ecebdde488 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_default.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_default.py
@@ -46,6 +46,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/BatchAccountCreate_Default.json
+# x-ms-original-file: 2026-10-01/BatchAccountCreate_Default.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_system_assigned_identity.py b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_system_assigned_identity.py
index a12cfb6a87a8..135bde83fa0b 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_system_assigned_identity.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_system_assigned_identity.py
@@ -47,6 +47,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/BatchAccountCreate_SystemAssignedIdentity.json
+# x-ms-original-file: 2026-10-01/BatchAccountCreate_SystemAssignedIdentity.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_user_assigned_identity.py b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_user_assigned_identity.py
index 70ffd18b6208..6fb095bb8054 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_user_assigned_identity.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_create_user_assigned_identity.py
@@ -52,6 +52,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/BatchAccountCreate_UserAssignedIdentity.json
+# x-ms-original-file: 2026-10-01/BatchAccountCreate_UserAssignedIdentity.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_delete.py b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_delete.py
index c1a61e4afb53..2c9778a23667 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_delete.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_delete.py
@@ -36,6 +36,6 @@ def main():
).result()
-# x-ms-original-file: 2025-06-01/BatchAccountDelete.json
+# x-ms-original-file: 2026-10-01/BatchAccountDelete.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_get.py b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_get.py
index ccdb68214ec9..4f65812f148f 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_get.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_get.py
@@ -37,6 +37,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/BatchAccountGet.json
+# x-ms-original-file: 2026-10-01/BatchAccountGet.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_get_keys.py b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_get_keys.py
index b853726b90e3..c705f046bb97 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_get_keys.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_get_keys.py
@@ -37,6 +37,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/BatchAccountGetKeys.json
+# x-ms-original-file: 2026-10-01/BatchAccountGetKeys.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_list.py b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_list.py
index a992e6884e22..2a4b7617393e 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_list.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_list.py
@@ -35,6 +35,6 @@ def main():
print(item)
-# x-ms-original-file: 2025-06-01/BatchAccountList.json
+# x-ms-original-file: 2026-10-01/BatchAccountList.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_list_by_resource_group.py b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_list_by_resource_group.py
index 2a662ca2aa21..46fe1709a18e 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_list_by_resource_group.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_list_by_resource_group.py
@@ -37,6 +37,6 @@ def main():
print(item)
-# x-ms-original-file: 2025-06-01/BatchAccountListByResourceGroup.json
+# x-ms-original-file: 2026-10-01/BatchAccountListByResourceGroup.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_list_outbound_network_dependencies_endpoints.py b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_list_outbound_network_dependencies_endpoints.py
index a1720c12a531..60dce9c471d3 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_list_outbound_network_dependencies_endpoints.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_list_outbound_network_dependencies_endpoints.py
@@ -38,6 +38,6 @@ def main():
print(item)
-# x-ms-original-file: 2025-06-01/BatchAccountListOutboundNetworkDependenciesEndpoints.json
+# x-ms-original-file: 2026-10-01/BatchAccountListOutboundNetworkDependenciesEndpoints.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_regenerate_key.py b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_regenerate_key.py
index d76fe9769a7d..b3519cdb93b4 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_regenerate_key.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_regenerate_key.py
@@ -38,6 +38,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/BatchAccountRegenerateKey.json
+# x-ms-original-file: 2026-10-01/BatchAccountRegenerateKey.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_synchronize_auto_storage_keys.py b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_synchronize_auto_storage_keys.py
index ef6f99877083..b109fe4b31d6 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_synchronize_auto_storage_keys.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_synchronize_auto_storage_keys.py
@@ -36,6 +36,6 @@ def main():
)
-# x-ms-original-file: 2025-06-01/BatchAccountSynchronizeAutoStorageKeys.json
+# x-ms-original-file: 2026-10-01/BatchAccountSynchronizeAutoStorageKeys.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_update.py b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_update.py
index 1c573b17b036..314a90b9c66f 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_update.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/batch_account_update.py
@@ -45,6 +45,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/BatchAccountUpdate.json
+# x-ms-original-file: 2026-10-01/BatchAccountUpdate.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/detector_get.py b/sdk/batch/azure-mgmt-batch/generated_samples/detector_get.py
index 2c774824054a..6ae823d9148b 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/detector_get.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/detector_get.py
@@ -38,6 +38,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/DetectorGet.json
+# x-ms-original-file: 2026-10-01/DetectorGet.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/detector_list.py b/sdk/batch/azure-mgmt-batch/generated_samples/detector_list.py
index 41391e0c8742..afafc552603c 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/detector_list.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/detector_list.py
@@ -38,6 +38,6 @@ def main():
print(item)
-# x-ms-original-file: 2025-06-01/DetectorList.json
+# x-ms-original-file: 2026-10-01/DetectorList.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/location_check_name_availability_already_exists.py b/sdk/batch/azure-mgmt-batch/generated_samples/location_check_name_availability_already_exists.py
index 7b546f142509..571d6e68b538 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/location_check_name_availability_already_exists.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/location_check_name_availability_already_exists.py
@@ -37,6 +37,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/LocationCheckNameAvailability_AlreadyExists.json
+# x-ms-original-file: 2026-10-01/LocationCheckNameAvailability_AlreadyExists.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/location_check_name_availability_available.py b/sdk/batch/azure-mgmt-batch/generated_samples/location_check_name_availability_available.py
index 6d9bfbffa270..720cb5f388e3 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/location_check_name_availability_available.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/location_check_name_availability_available.py
@@ -37,6 +37,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/LocationCheckNameAvailability_Available.json
+# x-ms-original-file: 2026-10-01/LocationCheckNameAvailability_Available.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/location_get_quotas.py b/sdk/batch/azure-mgmt-batch/generated_samples/location_get_quotas.py
index d34a052decef..94b761008b46 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/location_get_quotas.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/location_get_quotas.py
@@ -36,6 +36,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/LocationGetQuotas.json
+# x-ms-original-file: 2026-10-01/LocationGetQuotas.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/location_list_virtual_machine_skus.py b/sdk/batch/azure-mgmt-batch/generated_samples/location_list_virtual_machine_skus.py
index 893689f14250..148bfc0e0ccb 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/location_list_virtual_machine_skus.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/location_list_virtual_machine_skus.py
@@ -37,6 +37,6 @@ def main():
print(item)
-# x-ms-original-file: 2025-06-01/LocationListVirtualMachineSkus.json
+# x-ms-original-file: 2026-10-01/LocationListVirtualMachineSkus.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/nsp_configuration_get.py b/sdk/batch/azure-mgmt-batch/generated_samples/nsp_configuration_get.py
index 833b23890bff..bb476850caf2 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/nsp_configuration_get.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/nsp_configuration_get.py
@@ -38,6 +38,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/NspConfigurationGet.json
+# x-ms-original-file: 2026-10-01/NspConfigurationGet.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/nsp_configuration_reconcile.py b/sdk/batch/azure-mgmt-batch/generated_samples/nsp_configuration_reconcile.py
index 0f1affd97046..d3ed6732d035 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/nsp_configuration_reconcile.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/nsp_configuration_reconcile.py
@@ -37,6 +37,6 @@ def main():
).result()
-# x-ms-original-file: 2025-06-01/NspConfigurationReconcile.json
+# x-ms-original-file: 2026-10-01/NspConfigurationReconcile.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/nsp_configurations_list.py b/sdk/batch/azure-mgmt-batch/generated_samples/nsp_configurations_list.py
index d596f45fbfb9..b6735180fe95 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/nsp_configurations_list.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/nsp_configurations_list.py
@@ -38,6 +38,6 @@ def main():
print(item)
-# x-ms-original-file: 2025-06-01/NspConfigurationsList.json
+# x-ms-original-file: 2026-10-01/NspConfigurationsList.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/operations_list.py b/sdk/batch/azure-mgmt-batch/generated_samples/operations_list.py
index a0ffbf7ff48b..3939f1eb4efc 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/operations_list.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/operations_list.py
@@ -35,6 +35,6 @@ def main():
print(item)
-# x-ms-original-file: 2025-06-01/OperationsList.json
+# x-ms-original-file: 2026-10-01/OperationsList.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_accelerated_networking.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_accelerated_networking.py
index 1ee9268907c2..92d81d5768fa 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_accelerated_networking.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_accelerated_networking.py
@@ -60,6 +60,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_AcceleratedNetworking.json
+# x-ms-original-file: 2026-10-01/PoolCreate_AcceleratedNetworking.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_confidential_disk_encryption_set_for_user_subscription_accounts.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_confidential_disk_encryption_set_for_user_subscription_accounts.py
index 4a7d6dd2c1fd..82ed3ee36a7a 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_confidential_disk_encryption_set_for_user_subscription_accounts.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_confidential_disk_encryption_set_for_user_subscription_accounts.py
@@ -88,6 +88,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_ConfidentialDiskEncryptionSet_ForUserSubscriptionAccounts.json
+# x-ms-original-file: 2026-10-01/PoolCreate_ConfidentialDiskEncryptionSet_ForUserSubscriptionAccounts.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_customer_managed_key_for_batch_managed_accounts.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_customer_managed_key_for_batch_managed_accounts.py
index bae70855cc01..f7858836d480 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_customer_managed_key_for_batch_managed_accounts.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_customer_managed_key_for_batch_managed_accounts.py
@@ -71,6 +71,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_CustomerManagedKey_ForBatchManagedAccounts.json
+# x-ms-original-file: 2026-10-01/PoolCreate_CustomerManagedKey_ForBatchManagedAccounts.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_disk_encryption_set_for_user_subscription_accounts.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_disk_encryption_set_for_user_subscription_accounts.py
index e220dce15656..c2cf6407df7f 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_disk_encryption_set_for_user_subscription_accounts.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_disk_encryption_set_for_user_subscription_accounts.py
@@ -66,6 +66,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_DiskEncryptionSet_ForUserSubscriptionAccounts.json
+# x-ms-original-file: 2026-10-01/PoolCreate_DiskEncryptionSet_ForUserSubscriptionAccounts.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_dual_stack_networking.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_dual_stack_networking.py
index fd981dde1dcd..1b8f06bfd8b9 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_dual_stack_networking.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_dual_stack_networking.py
@@ -72,6 +72,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_DualStackNetworking.json
+# x-ms-original-file: 2026-10-01/PoolCreate_DualStackNetworking.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_minimal_virtual_machine_configuration.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_minimal_virtual_machine_configuration.py
index 039a6ae7ea53..47a999615df4 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_minimal_virtual_machine_configuration.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_minimal_virtual_machine_configuration.py
@@ -55,6 +55,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_MinimalVirtualMachineConfiguration.json
+# x-ms-original-file: 2026-10-01/PoolCreate_MinimalVirtualMachineConfiguration.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_no_public_ip_addresses.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_no_public_ip_addresses.py
index af2607b5c617..2887ac5e1182 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_no_public_ip_addresses.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_no_public_ip_addresses.py
@@ -56,6 +56,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_NoPublicIPAddresses.json
+# x-ms-original-file: 2026-10-01/PoolCreate_NoPublicIPAddresses.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_public_ips.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_public_ips.py
index c957ac1bc54f..6da92f9d27cb 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_public_ips.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_public_ips.py
@@ -61,6 +61,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_PublicIPs.json
+# x-ms-original-file: 2026-10-01/PoolCreate_PublicIPs.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_security_profile.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_security_profile.py
index fbb61b6dd5b8..40b8bd64f2c6 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_security_profile.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_security_profile.py
@@ -48,7 +48,7 @@ def main():
"securityProfile": {
"encryptionAtHost": True,
"securityType": "trustedLaunch",
- "uefiSettings": {"secureBootEnabled": None, "vTpmEnabled": False},
+ "uefiSettings": {"vTpmEnabled": False},
},
}
},
@@ -60,6 +60,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_SecurityProfile.json
+# x-ms-original-file: 2026-10-01/PoolCreate_SecurityProfile.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_shared_image_gallery.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_shared_image_gallery.py
index 16e2a03bf8a7..514d8634aa89 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_shared_image_gallery.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_shared_image_gallery.py
@@ -52,6 +52,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_SharedImageGallery.json
+# x-ms-original-file: 2026-10-01/PoolCreate_SharedImageGallery.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_tags.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_tags.py
index f9a318e242e5..9f82376ec886 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_tags.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_tags.py
@@ -55,6 +55,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_Tags.json
+# x-ms-original-file: 2026-10-01/PoolCreate_Tags.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_upgrade_policy.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_upgrade_policy.py
index c389ce2f2582..1511e4ef790e 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_upgrade_policy.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_upgrade_policy.py
@@ -75,6 +75,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_UpgradePolicy.json
+# x-ms-original-file: 2026-10-01/PoolCreate_UpgradePolicy.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_user_assigned_identities.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_user_assigned_identities.py
index c25be2fb7b4c..65068de3318f 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_user_assigned_identities.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_user_assigned_identities.py
@@ -63,6 +63,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_UserAssignedIdentities.json
+# x-ms-original-file: 2026-10-01/PoolCreate_UserAssignedIdentities.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration.py
index 7b5a5ccafb9f..bdf256a99920 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration.py
@@ -101,6 +101,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_VirtualMachineConfiguration.json
+# x-ms-original-file: 2026-10-01/PoolCreate_VirtualMachineConfiguration.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration_extensions.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration_extensions.py
index b77146cb1b6d..0bb481db480c 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration_extensions.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration_extensions.py
@@ -68,6 +68,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_VirtualMachineConfiguration_Extensions.json
+# x-ms-original-file: 2026-10-01/PoolCreate_VirtualMachineConfiguration_Extensions.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration_managed_os_disk.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration_managed_os_disk.py
index 1e8687a9c220..d4b49566c6b0 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration_managed_os_disk.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration_managed_os_disk.py
@@ -60,6 +60,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_VirtualMachineConfiguration_ManagedOSDisk.json
+# x-ms-original-file: 2026-10-01/PoolCreate_VirtualMachineConfiguration_ManagedOSDisk.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration_service_artifact_reference.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration_service_artifact_reference.py
index 9d421e05e4fa..10f38c986d63 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration_service_artifact_reference.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_create_virtual_machine_configuration_service_artifact_reference.py
@@ -61,6 +61,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolCreate_VirtualMachineConfiguration_ServiceArtifactReference.json
+# x-ms-original-file: 2026-10-01/PoolCreate_VirtualMachineConfiguration_ServiceArtifactReference.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_delete.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_delete.py
index 7632977f0d24..e20a1feb70af 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_delete.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_delete.py
@@ -37,6 +37,6 @@ def main():
).result()
-# x-ms-original-file: 2025-06-01/PoolDelete.json
+# x-ms-original-file: 2026-10-01/PoolDelete.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_disable_auto_scale.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_disable_auto_scale.py
index 10989e514233..0b6986f1ff35 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_disable_auto_scale.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_disable_auto_scale.py
@@ -38,6 +38,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolDisableAutoScale.json
+# x-ms-original-file: 2026-10-01/PoolDisableAutoScale.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_get.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_get.py
index 03bf1f468fb2..fa656ceb5e29 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_get.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_get.py
@@ -38,6 +38,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolGet.json
+# x-ms-original-file: 2026-10-01/PoolGet.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_accelerated_networking.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_accelerated_networking.py
index cb733e01b146..0dbe84f38ca8 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_accelerated_networking.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_accelerated_networking.py
@@ -38,6 +38,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolGet_AcceleratedNetworking.json
+# x-ms-original-file: 2026-10-01/PoolGet_AcceleratedNetworking.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_security_profile.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_security_profile.py
index ef236dbddc98..3e38cf9c0c6f 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_security_profile.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_security_profile.py
@@ -38,6 +38,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolGet_SecurityProfile.json
+# x-ms-original-file: 2026-10-01/PoolGet_SecurityProfile.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_upgrade_policy.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_upgrade_policy.py
index 28bcba861eef..74a9b98c97ba 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_upgrade_policy.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_upgrade_policy.py
@@ -38,6 +38,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolGet_UpgradePolicy.json
+# x-ms-original-file: 2026-10-01/PoolGet_UpgradePolicy.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_virtual_machine_configuration_extensions.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_virtual_machine_configuration_extensions.py
index 2af4a2cfb244..f5c522c5cec0 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_virtual_machine_configuration_extensions.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_virtual_machine_configuration_extensions.py
@@ -38,6 +38,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolGet_VirtualMachineConfiguration_Extensions.json
+# x-ms-original-file: 2026-10-01/PoolGet_VirtualMachineConfiguration_Extensions.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_virtual_machine_configuration_manged_os_disk.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_virtual_machine_configuration_manged_os_disk.py
index a952d4ceae12..e80cd8d61c9e 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_virtual_machine_configuration_manged_os_disk.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_virtual_machine_configuration_manged_os_disk.py
@@ -38,6 +38,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolGet_VirtualMachineConfiguration_MangedOSDisk.json
+# x-ms-original-file: 2026-10-01/PoolGet_VirtualMachineConfiguration_MangedOSDisk.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_virtual_machine_configuration_service_artifact_reference.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_virtual_machine_configuration_service_artifact_reference.py
index 607eb1634733..f7a2c2a3527a 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_virtual_machine_configuration_service_artifact_reference.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_get_virtual_machine_configuration_service_artifact_reference.py
@@ -38,6 +38,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolGet_VirtualMachineConfiguration_ServiceArtifactReference.json
+# x-ms-original-file: 2026-10-01/PoolGet_VirtualMachineConfiguration_ServiceArtifactReference.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_list.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_list.py
index 891941d796ca..938b613275d2 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_list.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_list.py
@@ -38,6 +38,6 @@ def main():
print(item)
-# x-ms-original-file: 2025-06-01/PoolList.json
+# x-ms-original-file: 2026-10-01/PoolList.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_list_with_filter.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_list_with_filter.py
index 75b3a66b0484..ab3ed5b86446 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_list_with_filter.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_list_with_filter.py
@@ -38,6 +38,6 @@ def main():
print(item)
-# x-ms-original-file: 2025-06-01/PoolListWithFilter.json
+# x-ms-original-file: 2026-10-01/PoolListWithFilter.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_stop_resize.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_stop_resize.py
index f41d94656e33..4447bfa79329 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_stop_resize.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_stop_resize.py
@@ -38,6 +38,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolStopResize.json
+# x-ms-original-file: 2026-10-01/PoolStopResize.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_enable_auto_scale.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_enable_auto_scale.py
index c2c461ed4203..abfa90f57b8c 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_enable_auto_scale.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_enable_auto_scale.py
@@ -39,6 +39,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolUpdate_EnableAutoScale.json
+# x-ms-original-file: 2026-10-01/PoolUpdate_EnableAutoScale.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_other_properties.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_other_properties.py
index a3357e1b42cf..1f9a7ecb6c28 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_other_properties.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_other_properties.py
@@ -53,6 +53,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolUpdate_OtherProperties.json
+# x-ms-original-file: 2026-10-01/PoolUpdate_OtherProperties.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_remove_start_task.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_remove_start_task.py
index fff622920a7f..329954a3da62 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_remove_start_task.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_remove_start_task.py
@@ -39,6 +39,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolUpdate_RemoveStartTask.json
+# x-ms-original-file: 2026-10-01/PoolUpdate_RemoveStartTask.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_resize_pool.py b/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_resize_pool.py
index 18911cd32d4b..86b42a1c5c05 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_resize_pool.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/pool_update_resize_pool.py
@@ -50,6 +50,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PoolUpdate_ResizePool.json
+# x-ms-original-file: 2026-10-01/PoolUpdate_ResizePool.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/private_batch_account_create.py b/sdk/batch/azure-mgmt-batch/generated_samples/private_batch_account_create.py
index 53935c5612ee..e069c83702de 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/private_batch_account_create.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/private_batch_account_create.py
@@ -51,6 +51,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PrivateBatchAccountCreate.json
+# x-ms-original-file: 2026-10-01/PrivateBatchAccountCreate.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/private_batch_account_get.py b/sdk/batch/azure-mgmt-batch/generated_samples/private_batch_account_get.py
index 090b94b3923a..3286d3db3a61 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/private_batch_account_get.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/private_batch_account_get.py
@@ -37,6 +37,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PrivateBatchAccountGet.json
+# x-ms-original-file: 2026-10-01/PrivateBatchAccountGet.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connection_delete.py b/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connection_delete.py
index 7dda61c08b8e..c6c94fe6f10d 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connection_delete.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connection_delete.py
@@ -38,6 +38,6 @@ def main():
).result()
-# x-ms-original-file: 2025-06-01/PrivateEndpointConnectionDelete.json
+# x-ms-original-file: 2026-10-01/PrivateEndpointConnectionDelete.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connection_get.py b/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connection_get.py
index 8c4b10f87d5f..2515b26cd2d1 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connection_get.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connection_get.py
@@ -39,6 +39,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PrivateEndpointConnectionGet.json
+# x-ms-original-file: 2026-10-01/PrivateEndpointConnectionGet.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connection_update.py b/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connection_update.py
index 9b1aedc81bfc..7f380cd86ae6 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connection_update.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connection_update.py
@@ -46,6 +46,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PrivateEndpointConnectionUpdate.json
+# x-ms-original-file: 2026-10-01/PrivateEndpointConnectionUpdate.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connections_list.py b/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connections_list.py
index 0dd2abba928b..4ae550ed4aa3 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connections_list.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/private_endpoint_connections_list.py
@@ -38,6 +38,6 @@ def main():
print(item)
-# x-ms-original-file: 2025-06-01/PrivateEndpointConnectionsList.json
+# x-ms-original-file: 2026-10-01/PrivateEndpointConnectionsList.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/private_link_resource_get.py b/sdk/batch/azure-mgmt-batch/generated_samples/private_link_resource_get.py
index 530034c78619..f6d4811b0d54 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/private_link_resource_get.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/private_link_resource_get.py
@@ -38,6 +38,6 @@ def main():
print(response)
-# x-ms-original-file: 2025-06-01/PrivateLinkResourceGet.json
+# x-ms-original-file: 2026-10-01/PrivateLinkResourceGet.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_samples/private_link_resources_list.py b/sdk/batch/azure-mgmt-batch/generated_samples/private_link_resources_list.py
index 3a4399a5f425..11bdff0f8746 100644
--- a/sdk/batch/azure-mgmt-batch/generated_samples/private_link_resources_list.py
+++ b/sdk/batch/azure-mgmt-batch/generated_samples/private_link_resources_list.py
@@ -38,6 +38,6 @@ def main():
print(item)
-# x-ms-original-file: 2025-06-01/PrivateLinkResourcesList.json
+# x-ms-original-file: 2026-10-01/PrivateLinkResourcesList.json
if __name__ == "__main__":
main()
diff --git a/sdk/batch/azure-mgmt-batch/generated_tests/test_batch_management_pool_operations.py b/sdk/batch/azure-mgmt-batch/generated_tests/test_batch_management_pool_operations.py
index f45294a12305..e2736a234852 100644
--- a/sdk/batch/azure-mgmt-batch/generated_tests/test_batch_management_pool_operations.py
+++ b/sdk/batch/azure-mgmt-batch/generated_tests/test_batch_management_pool_operations.py
@@ -117,6 +117,7 @@ def test_pool_create(self, resource_group):
"typeHandlerVersion": "str",
}
],
+ "hardwareProfile": {"vmSizeProperties": {"vCPUsAvailable": 0, "vCPUsPerCore": 0}},
"licenseType": "str",
"nodePlacementConfiguration": {"policy": "str"},
"osDisk": {
@@ -133,6 +134,13 @@ def test_pool_create(self, resource_group):
},
"writeAcceleratorEnabled": bool,
},
+ "placement": {"zonePlacementPolicy": "str"},
+ "resiliencyPolicy": {
+ "zoneAllocationPolicy": {
+ "maxInstancePercentPerZonePolicy": {"value": 0, "enabled": bool},
+ "maxZoneCount": 0,
+ }
+ },
"securityProfile": {
"encryptionAtHost": bool,
"proxyAgentSettings": {
@@ -292,6 +300,7 @@ def test_pool_create(self, resource_group):
}
],
"vmSize": "str",
+ "vmSkuProfile": {"allocationStrategy": "str", "vmSizes": [{"name": "str", "rank": 0}]},
},
"systemData": {
"createdAt": "2020-02-20 00:00:00",
@@ -323,7 +332,6 @@ def test_pool_update(self, resource_group):
"type": "str",
"userAssignedIdentities": {"str": {"clientId": "str", "principalId": "str"}},
},
- "name": "str",
"properties": {
"allocationState": "str",
"allocationStateTransitionTime": "2020-02-20 00:00:00",
@@ -396,6 +404,7 @@ def test_pool_update(self, resource_group):
"typeHandlerVersion": "str",
}
],
+ "hardwareProfile": {"vmSizeProperties": {"vCPUsAvailable": 0, "vCPUsPerCore": 0}},
"licenseType": "str",
"nodePlacementConfiguration": {"policy": "str"},
"osDisk": {
@@ -412,6 +421,13 @@ def test_pool_update(self, resource_group):
},
"writeAcceleratorEnabled": bool,
},
+ "placement": {"zonePlacementPolicy": "str"},
+ "resiliencyPolicy": {
+ "zoneAllocationPolicy": {
+ "maxInstancePercentPerZonePolicy": {"enabled": bool, "value": 0},
+ "maxZoneCount": 0,
+ }
+ },
"securityProfile": {
"encryptionAtHost": bool,
"proxyAgentSettings": {
@@ -571,6 +587,7 @@ def test_pool_update(self, resource_group):
}
],
"vmSize": "str",
+ "vmSkuProfile": {"allocationStrategy": "str", "vmSizes": [{"name": "str", "rank": 0}]},
},
"systemData": {
"createdAt": "2020-02-20 00:00:00",
@@ -581,7 +598,6 @@ def test_pool_update(self, resource_group):
"lastModifiedByType": "str",
},
"tags": {"str": "str"},
- "type": "str",
},
)
diff --git a/sdk/batch/azure-mgmt-batch/generated_tests/test_batch_management_pool_operations_async.py b/sdk/batch/azure-mgmt-batch/generated_tests/test_batch_management_pool_operations_async.py
index 446c4eda21f4..bdb6fe8458cb 100644
--- a/sdk/batch/azure-mgmt-batch/generated_tests/test_batch_management_pool_operations_async.py
+++ b/sdk/batch/azure-mgmt-batch/generated_tests/test_batch_management_pool_operations_async.py
@@ -118,6 +118,7 @@ async def test_pool_create(self, resource_group):
"typeHandlerVersion": "str",
}
],
+ "hardwareProfile": {"vmSizeProperties": {"vCPUsAvailable": 0, "vCPUsPerCore": 0}},
"licenseType": "str",
"nodePlacementConfiguration": {"policy": "str"},
"osDisk": {
@@ -134,6 +135,13 @@ async def test_pool_create(self, resource_group):
},
"writeAcceleratorEnabled": bool,
},
+ "placement": {"zonePlacementPolicy": "str"},
+ "resiliencyPolicy": {
+ "zoneAllocationPolicy": {
+ "maxInstancePercentPerZonePolicy": {"value": 0, "enabled": bool},
+ "maxZoneCount": 0,
+ }
+ },
"securityProfile": {
"encryptionAtHost": bool,
"proxyAgentSettings": {
@@ -293,6 +301,7 @@ async def test_pool_create(self, resource_group):
}
],
"vmSize": "str",
+ "vmSkuProfile": {"allocationStrategy": "str", "vmSizes": [{"name": "str", "rank": 0}]},
},
"systemData": {
"createdAt": "2020-02-20 00:00:00",
@@ -324,7 +333,6 @@ async def test_pool_update(self, resource_group):
"type": "str",
"userAssignedIdentities": {"str": {"clientId": "str", "principalId": "str"}},
},
- "name": "str",
"properties": {
"allocationState": "str",
"allocationStateTransitionTime": "2020-02-20 00:00:00",
@@ -397,6 +405,7 @@ async def test_pool_update(self, resource_group):
"typeHandlerVersion": "str",
}
],
+ "hardwareProfile": {"vmSizeProperties": {"vCPUsAvailable": 0, "vCPUsPerCore": 0}},
"licenseType": "str",
"nodePlacementConfiguration": {"policy": "str"},
"osDisk": {
@@ -413,6 +422,13 @@ async def test_pool_update(self, resource_group):
},
"writeAcceleratorEnabled": bool,
},
+ "placement": {"zonePlacementPolicy": "str"},
+ "resiliencyPolicy": {
+ "zoneAllocationPolicy": {
+ "maxInstancePercentPerZonePolicy": {"enabled": bool, "value": 0},
+ "maxZoneCount": 0,
+ }
+ },
"securityProfile": {
"encryptionAtHost": bool,
"proxyAgentSettings": {
@@ -572,6 +588,7 @@ async def test_pool_update(self, resource_group):
}
],
"vmSize": "str",
+ "vmSkuProfile": {"allocationStrategy": "str", "vmSizes": [{"name": "str", "rank": 0}]},
},
"systemData": {
"createdAt": "2020-02-20 00:00:00",
@@ -582,7 +599,6 @@ async def test_pool_update(self, resource_group):
"lastModifiedByType": "str",
},
"tags": {"str": "str"},
- "type": "str",
},
)
diff --git a/sdk/batch/azure-mgmt-batch/pyproject.toml b/sdk/batch/azure-mgmt-batch/pyproject.toml
index 634f28e7e2b6..d81ebcc798a7 100644
--- a/sdk/batch/azure-mgmt-batch/pyproject.toml
+++ b/sdk/batch/azure-mgmt-batch/pyproject.toml
@@ -17,13 +17,14 @@ classifiers = [
"Programming Language :: Python",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3",
- "Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
+ "Programming Language :: Python :: 3.14",
+ "Programming Language :: Python :: 3.15",
]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
keywords = [
"azure",
"azure sdk",
diff --git a/sdk/batch/azure-mgmt-batch/tests/test_batch_pool_unit.py b/sdk/batch/azure-mgmt-batch/tests/test_batch_pool_unit.py
new file mode 100644
index 000000000000..09566ce6d258
--- /dev/null
+++ b/sdk/batch/azure-mgmt-batch/tests/test_batch_pool_unit.py
@@ -0,0 +1,271 @@
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# --------------------------------------------------------------------------
+
+import json
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, Mock
+from urllib.parse import parse_qs, urlsplit
+
+import pytest
+
+from azure.core import MatchConditions
+from azure.core.exceptions import ResourceModifiedError
+from azure.core.rest import HttpResponse
+from azure.mgmt.batch import BatchManagementClient, models
+from azure.mgmt.batch.aio import BatchManagementClient as AsyncBatchManagementClient
+
+
+@pytest.fixture(scope="session", autouse=True)
+def add_sanitizers():
+ """These mocked unit tests do not send traffic or need the test proxy."""
+ yield
+
+
+@pytest.fixture
+def pool_with_new_features():
+ return models.Pool(
+ properties=models.PoolProperties(
+ vm_size="Mix",
+ vm_sku_profile=models.VirtualMachineSkuProfile(
+ vm_sizes=[
+ models.VirtualMachineSkuProfileVmSize(name="Standard_D8s_v5", rank=0),
+ models.VirtualMachineSkuProfileVmSize(name="Standard_D8as_v5", rank=1),
+ ],
+ allocation_strategy=models.VirtualMachineSkuAllocationStrategy.PRIORITIZED,
+ ),
+ deployment_configuration=models.DeploymentConfiguration(
+ virtual_machine_configuration=models.VirtualMachineConfiguration(
+ image_reference=models.ImageReference(
+ publisher="Canonical", offer="ubuntu-24_04-lts", sku="server", version="latest"
+ ),
+ node_agent_sku_id="batch.node.ubuntu 24.04",
+ hardware_profile=models.HardwareProfile(
+ vm_size_properties=models.VmSizeProperties(v_cpus_available=4, v_cpus_per_core=1)
+ ),
+ placement=models.Placement(zone_placement_policy=models.ZonePlacementPolicyType.AUTO),
+ resiliency_policy=models.ResiliencyPolicy(
+ zone_allocation_policy=models.ZoneAllocationPolicy(
+ max_zone_count=3,
+ max_instance_percent_per_zone_policy=models.MaxInstancePercentPerZonePolicy(
+ enabled=True, value=50
+ ),
+ )
+ ),
+ )
+ ),
+ )
+ )
+
+
+@pytest.fixture
+def partial_pool_patch():
+ return models.PoolPatch(
+ properties=models.PoolPatchProperties(
+ deployment_configuration=models.DeploymentConfigurationPatch(
+ virtual_machine_configuration=models.VirtualMachineConfigurationPatch(
+ image_reference=models.ImageReference(
+ publisher="Canonical", offer="ubuntu-24_04-lts", sku="server", version="latest"
+ ),
+ node_agent_sku_id="batch.node.ubuntu 24.04",
+ placement=models.PlacementPatch(zone_placement_policy=models.ZonePlacementPolicyType.AUTO),
+ resiliency_policy=models.ResiliencyPolicyPatch(
+ zone_allocation_policy=models.ZoneAllocationPolicyPatch(
+ max_instance_percent_per_zone_policy=models.MaxInstancePercentPerZonePolicyPatch(
+ enabled=False
+ )
+ )
+ ),
+ )
+ )
+ )
+ )
+
+
+class TestBatchPoolModels:
+ def test_removed_authentication_mode(self):
+ assert not hasattr(models.AuthenticationMode, "TASK_AUTHENTICATION_TOKEN")
+ with pytest.raises(ValueError):
+ models.AuthenticationMode("TaskAuthenticationToken")
+ assert {mode.value for mode in models.AuthenticationMode} == {"SharedKey", "AAD"}
+
+ @pytest.mark.parametrize("option", ["Requeue", "Terminate", "TaskCompletion"])
+ def test_requested_deallocation_options(self, option):
+ settings = models.FixedScaleSettings(
+ target_dedicated_nodes=0,
+ node_deallocation_option=models.RequestedComputeNodeDeallocationOption(option),
+ )
+ assert settings.as_dict(exclude_readonly=True) == {
+ "targetDedicatedNodes": 0,
+ "nodeDeallocationOption": option,
+ }
+
+ def test_retained_data_is_response_only_enum_value(self):
+ assert not hasattr(models.RequestedComputeNodeDeallocationOption, "RETAINED_DATA")
+ with pytest.raises(ValueError):
+ models.RequestedComputeNodeDeallocationOption("RetainedData")
+ status = models.ResizeOperationStatus({"nodeDeallocationOption": "RetainedData"})
+ assert status.node_deallocation_option == models.ComputeNodeDeallocationOption.RETAINED_DATA
+
+ @pytest.mark.parametrize("strategy", ["LowestPrice", "CapacityOptimized", "Prioritized"])
+ def test_vm_sku_allocation_strategies(self, strategy):
+ rank = 0 if strategy == "Prioritized" else None
+ profile = models.VirtualMachineSkuProfile(
+ vm_sizes=[models.VirtualMachineSkuProfileVmSize(name="Standard_D8s_v5", rank=rank)],
+ allocation_strategy=models.VirtualMachineSkuAllocationStrategy(strategy),
+ )
+ expected_size = {"name": "Standard_D8s_v5"}
+ if rank is not None:
+ expected_size["rank"] = rank
+ assert profile.as_dict() == {"vmSizes": [expected_size], "allocationStrategy": strategy}
+ restored = models.VirtualMachineSkuProfile(profile.as_dict())
+ assert isinstance(restored.vm_sizes[0], models.VirtualMachineSkuProfileVmSize)
+ assert restored.vm_sizes[0].rank == rank
+ assert restored.allocation_strategy == strategy
+
+ def test_new_pool_features_serialization(self, pool_with_new_features):
+ properties = pool_with_new_features.as_dict(exclude_readonly=True)["properties"]
+ assert properties["vmSize"] == "Mix"
+ assert properties["vmSkuProfile"] == {
+ "vmSizes": [
+ {"name": "Standard_D8s_v5", "rank": 0},
+ {"name": "Standard_D8as_v5", "rank": 1},
+ ],
+ "allocationStrategy": "Prioritized",
+ }
+ vm = properties["deploymentConfiguration"]["virtualMachineConfiguration"]
+ assert vm["hardwareProfile"] == {"vmSizeProperties": {"vCPUsAvailable": 4, "vCPUsPerCore": 1}}
+ assert vm["placement"] == {"zonePlacementPolicy": "Auto"}
+ assert vm["resiliencyPolicy"] == {
+ "zoneAllocationPolicy": {
+ "maxZoneCount": 3,
+ "maxInstancePercentPerZonePolicy": {"enabled": True, "value": 50},
+ }
+ }
+
+ def test_new_pool_features_deserialization(self, pool_with_new_features):
+ pool = models.Pool(pool_with_new_features.as_dict())
+ assert isinstance(pool.properties.vm_sku_profile, models.VirtualMachineSkuProfile)
+ assert pool.properties.vm_sku_profile.vm_sizes[0].rank == 0
+ vm = pool.properties.deployment_configuration.virtual_machine_configuration
+ assert isinstance(vm.hardware_profile, models.HardwareProfile)
+ assert isinstance(vm.hardware_profile.vm_size_properties, models.VmSizeProperties)
+ assert vm.hardware_profile.vm_size_properties.v_cpus_available == 4
+ assert vm.hardware_profile.vm_size_properties.v_cpus_per_core == 1
+ assert isinstance(vm.placement, models.Placement)
+ assert vm.placement.zone_placement_policy == models.ZonePlacementPolicyType.AUTO
+ assert isinstance(vm.resiliency_policy, models.ResiliencyPolicy)
+ policy = vm.resiliency_policy.zone_allocation_policy
+ assert isinstance(policy, models.ZoneAllocationPolicy)
+ assert policy.max_zone_count == 3
+ assert isinstance(policy.max_instance_percent_per_zone_policy, models.MaxInstancePercentPerZonePolicy)
+ assert policy.max_instance_percent_per_zone_policy.enabled is True
+ assert policy.max_instance_percent_per_zone_policy.value == 50
+
+ def test_partial_zone_patch_omits_unspecified_fields(self, partial_pool_patch):
+ properties = partial_pool_patch.as_dict(exclude_readonly=True)["properties"]
+ assert set(properties) == {"deploymentConfiguration"}
+ vm = properties["deploymentConfiguration"]["virtualMachineConfiguration"]
+ assert vm["placement"] == {"zonePlacementPolicy": "Auto"}
+ assert vm["resiliencyPolicy"] == {
+ "zoneAllocationPolicy": {"maxInstancePercentPerZonePolicy": {"enabled": False}}
+ }
+ assert "hardwareProfile" not in vm
+
+ def test_empty_patch_and_explicit_null_are_distinct(self):
+ assert models.PoolPatch().as_dict(exclude_readonly=True) == {}
+ patch = models.PoolPatch(properties=models.PoolPatchProperties({"startTask": None}))
+ assert patch.as_dict(exclude_readonly=True) == {"properties": {"startTask": None}}
+
+ def test_patch_excludes_readonly_fields(self):
+ patch = models.PoolPatch(
+ {
+ "id": "/subscriptions/sub/resourceGroups/group/providers/Microsoft.Batch/batchAccounts/account/pools/pool",
+ "etag": "old-etag",
+ "systemData": {"createdBy": "example"},
+ "tags": {"environment": "test"},
+ "properties": {"currentDedicatedNodes": 2, "displayName": "updated"},
+ }
+ )
+ assert patch.as_dict(exclude_readonly=True) == {
+ "tags": {"environment": "test"},
+ "properties": {"displayName": "updated"},
+ }
+
+
+class TestBatchPoolOperations:
+ @pytest.mark.asyncio
+ @pytest.mark.parametrize("is_async", [False, True], ids=["sync", "async"])
+ @pytest.mark.parametrize("operation", ["create", "get", "update"])
+ async def test_new_features_on_wire(
+ self, monkeypatch, pool_with_new_features, partial_pool_patch, is_async, operation
+ ):
+ client_type = AsyncBatchManagementClient if is_async else BatchManagementClient
+ client = client_type(credential=Mock(), subscription_id="00000000-0000-0000-0000-000000000000")
+ response = Mock(spec=HttpResponse)
+ response.status_code = 200
+ response.headers = {"ETag": "new-etag"}
+ response.json.return_value = pool_with_new_features.as_dict()
+ run = (AsyncMock if is_async else Mock)(return_value=SimpleNamespace(http_response=response))
+ monkeypatch.setattr(client._client._pipeline, "run", run)
+ try:
+ parameters = []
+ if operation != "get":
+ parameters.append(partial_pool_patch if operation == "update" else pool_with_new_features)
+ result = getattr(client.pool, operation)("group", "account", "pool", *parameters)
+ if is_async:
+ result = await result
+ run.assert_called_once()
+ request = run.call_args.args[0]
+ assert request.method == {"create": "PUT", "get": "GET", "update": "PATCH"}[operation]
+ url = urlsplit(request.url)
+ assert url.path.endswith("/resourceGroups/group/providers/Microsoft.Batch/batchAccounts/account/pools/pool")
+ assert parse_qs(url.query)["api-version"] == ["2026-10-01"]
+ if parameters:
+ assert request.headers["Content-Type"] == "application/json"
+ assert json.loads(request.content) == parameters[0].as_dict(exclude_readonly=True)
+ assert isinstance(result, models.Pool)
+ assert isinstance(result.properties.vm_sku_profile, models.VirtualMachineSkuProfile)
+ assert result.properties.vm_sku_profile.vm_sizes[0].rank == 0
+ vm = result.properties.deployment_configuration.virtual_machine_configuration
+ assert vm.hardware_profile.vm_size_properties.v_cpus_per_core == 1
+ assert vm.placement.zone_placement_policy == models.ZonePlacementPolicyType.AUTO
+ assert vm.resiliency_policy.zone_allocation_policy.max_instance_percent_per_zone_policy.value == 50
+ finally:
+ if is_async:
+ await client.close()
+ else:
+ client.close()
+
+ @pytest.mark.asyncio
+ @pytest.mark.parametrize("is_async", [False, True], ids=["sync", "async"])
+ async def test_pool_patch_preserves_etag_conflict(self, monkeypatch, partial_pool_patch, is_async):
+ client_type = AsyncBatchManagementClient if is_async else BatchManagementClient
+ client = client_type(credential=Mock(), subscription_id="00000000-0000-0000-0000-000000000000")
+ response = Mock(spec=HttpResponse)
+ response.status_code = 412
+ response.reason = "Precondition Failed"
+ response.headers = {"Content-Type": "application/json"}
+ response.json.return_value = {"error": {"code": "ConditionNotMet", "message": "The pool was modified."}}
+ run = (AsyncMock if is_async else Mock)(return_value=SimpleNamespace(http_response=response))
+ monkeypatch.setattr(client._client._pipeline, "run", run)
+ try:
+ with pytest.raises(ResourceModifiedError):
+ result = client.pool.update(
+ "group",
+ "account",
+ "pool",
+ partial_pool_patch,
+ etag="old-etag",
+ match_condition=MatchConditions.IfNotModified,
+ )
+ if is_async:
+ await result
+ run.assert_called_once()
+ assert run.call_args.args[0].headers["If-Match"] == '"old-etag"'
+ finally:
+ if is_async:
+ await client.close()
+ else:
+ client.close()
diff --git a/sdk/batch/azure-mgmt-batch/tsp-location.yaml b/sdk/batch/azure-mgmt-batch/tsp-location.yaml
index 965b7a4011f1..5532109ae1b4 100644
--- a/sdk/batch/azure-mgmt-batch/tsp-location.yaml
+++ b/sdk/batch/azure-mgmt-batch/tsp-location.yaml
@@ -1,4 +1,4 @@
directory: specification/batch/resource-manager/Microsoft.Batch/Batch
-commit: ed16e10caee8ef2ab09f321272877d0efbec0d1e
+commit: fe03f6284b62c767079c3f750d2e2f6c102dc6c9
repo: Azure/azure-rest-api-specs
additionalDirectories: