Location Services

def get_quotas(
    location_name: str,
    **kwargs: Any
) -> BatchLocationQuota:
    """
    Gets the Batch service quotas for the specified subscription at the given location.
    
    Args:
        location_name (str): The region for which to retrieve quota information
        
    Returns:
        BatchLocationQuota: The quota information for the location
    """

def list_supported_virtual_machine_skus(
    location_name: str,
    maxresults: int = None,
    filter: str = None,
    **kwargs: Any
) -> ItemPaged[SupportedSku]:
    """
    Gets the list of Batch-supported Virtual Machine VM sizes available at the given location.
    
    Args:
        location_name (str): The region for which to retrieve available sizes
        maxresults (int, optional): Maximum number of results to return
        filter (str, optional): OData filter clause
        
    Returns:
        ItemPaged[SupportedSku]: Paginated list of supported VM SKUs
    """

def check_name_availability(
    location_name: str,
    parameters: CheckNameAvailabilityParameters,
    **kwargs: Any
) -> CheckNameAvailabilityResult:
    """
    Checks whether the Batch account name is available in the specified region.
    
    Args:
        location_name (str): The desired region for the Batch account
        parameters (CheckNameAvailabilityParameters): Name availability check parameters
        
    Returns:
        CheckNameAvailabilityResult: The name availability result
    """

class BatchLocationQuota:
    account_quota: int
    
class VirtualMachineFamilyCoreQuota:
    name: str
    core_quota: int

class SupportedSku:
    name: str
    family_name: str
    capabilities: list
    
class SkuCapability:
    name: str
    value: str

class CheckNameAvailabilityParameters:
    name: str
    type: str
    
class CheckNameAvailabilityResult:
    name_available: bool
    reason: NameAvailabilityReason
    message: str
    
class NameAvailabilityReason:
    INVALID = "Invalid"
    ALREADY_EXISTS = "AlreadyExists"

# Get quota information for a region
quota_info = client.location.get_quotas("East US")
print(f"Account quota: {quota_info.account_quota}")

# List all supported VM SKUs in a region
skus = client.location.list_supported_virtual_machine_skus("East US")

print("Available VM SKUs:")
for sku in skus:
    print(f"- {sku.name} (Family: {sku.family_name})")
    
    # Show capabilities
    if sku.capabilities:
        for capability in sku.capabilities:
            print(f"  {capability.name}: {capability.value}")

# Filter SKUs by specific criteria
gpu_skus = client.location.list_supported_virtual_machine_skus(
    "East US",
    filter="familyName eq 'standardNCFamily'"
)

print("GPU-enabled SKUs:")
for sku in gpu_skus:
    print(f"- {sku.name}")

from azure.mgmt.batch.models import CheckNameAvailabilityParameters

# Check if a Batch account name is available
name_check = CheckNameAvailabilityParameters(
    name="my-desired-batch-account",
    type="Microsoft.Batch/batchAccounts"
)

availability = client.location.check_name_availability("East US", name_check)

if availability.name_available:
    print("Name is available!")
else:
    print(f"Name not available: {availability.reason}")
    print(f"Message: {availability.message}")

def plan_batch_deployment(region: str, desired_vm_family: str):
    """Plan a Batch deployment for a specific region and VM family."""
    
    # Check regional quotas
    quota = client.location.get_quotas(region)
    print(f"Region: {region}")
    print(f"Max Batch accounts: {quota.account_quota}")
    
    # Find available SKUs in the desired family
    family_filter = f"familyName eq '{desired_vm_family}'"
    skus = client.location.list_supported_virtual_machine_skus(
        region, 
        filter=family_filter
    )
    
    available_skus = list(skus)
    if available_skus:
        print(f"\nAvailable SKUs in {desired_vm_family} family:")
        for sku in available_skus:
            print(f"- {sku.name}")
        return True
    else:
        print(f"\nNo SKUs available in {desired_vm_family} family")
        return False

# Plan deployment
can_deploy = plan_batch_deployment("East US", "standardDFamily")

def analyze_regions(regions: list, vm_requirements: list):
    """Analyze multiple regions for VM availability."""
    
    results = {}
    
    for region in regions:
        print(f"\nAnalyzing {region}...")
        region_info = {
            "quota": client.location.get_quotas(region),
            "available_skus": set()
        }
        
        # Get all available SKUs
        skus = client.location.list_supported_virtual_machine_skus(region)
        for sku in skus:
            region_info["available_skus"].add(sku.name)
        
        # Check if required SKUs are available
        missing_skus = []
        for required_sku in vm_requirements:
            if required_sku not in region_info["available_skus"]:
                missing_skus.append(required_sku)
        
        region_info["missing_skus"] = missing_skus
        region_info["suitable"] = len(missing_skus) == 0
        
        results[region] = region_info
        
        print(f"  Account quota: {region_info['quota'].account_quota}")
        print(f"  Available SKUs: {len(region_info['available_skus'])}")
        print(f"  Suitable for requirements: {region_info['suitable']}")
        
        if missing_skus:
            print(f"  Missing SKUs: {', '.join(missing_skus)}")
    
    return results

# Analyze multiple regions
regions_to_check = ["East US", "West US 2", "UK South"]
required_vms = ["Standard_D2s_v3", "Standard_F4s_v2"]

analysis = analyze_regions(regions_to_check, required_vms)