Media Services Account Management

def list(resource_group_name: str) -> Iterable[MediaService]:
    """
    List all media services in a resource group.
    
    Parameters:
    - resource_group_name: Name of the resource group (str)
    
    Returns:
    Iterable of MediaService objects
    """

def get(resource_group_name: str, account_name: str) -> MediaService:
    """
    Get a specific media service account.
    
    Parameters:
    - resource_group_name: Name of the resource group (str)
    - account_name: Name of the media service account (str)
    
    Returns:
    MediaService object containing account details
    """

def list_by_subscription() -> Iterable[MediaService]:
    """
    List all media services in the current subscription.
    
    Returns:
    Iterable of MediaService objects across all resource groups
    """

def begin_create_or_update(
    resource_group_name: str,
    account_name: str, 
    parameters: MediaService
) -> LROPoller[MediaService]:
    """
    Create or update a media service account.
    
    Parameters:
    - resource_group_name: Name of the resource group (str)
    - account_name: Name of the media service account (str)
    - parameters: Media service configuration (MediaService)
    
    Returns:
    LROPoller for long-running operation tracking
    """

def begin_update(
    resource_group_name: str,
    account_name: str,
    parameters: MediaService
) -> LROPoller[MediaService]:
    """
    Update an existing media service account.
    
    Parameters:
    - resource_group_name: Name of the resource group (str)
    - account_name: Name of the media service account (str)
    - parameters: Updated media service configuration (MediaService)
    
    Returns:
    LROPoller for long-running operation tracking
    """

def delete(resource_group_name: str, account_name: str) -> None:
    """
    Delete a media service account.
    
    Parameters:
    - resource_group_name: Name of the resource group (str)
    - account_name: Name of the media service account (str)
    
    Returns:
    None
    """

def sync_storage_keys(
    resource_group_name: str,
    account_name: str,
    parameters: SyncStorageKeysInput
) -> None:
    """
    Synchronize storage account keys with the media service.
    
    Parameters:
    - resource_group_name: Name of the resource group (str)
    - account_name: Name of the media service account (str)
    - parameters: Storage key synchronization parameters (SyncStorageKeysInput)
    
    Returns:
    None
    """

def list_edge_policies(
    resource_group_name: str,
    account_name: str,
    parameters: ListEdgePoliciesInput
) -> EdgePolicies:
    """
    List edge policies for the media service account.
    
    Parameters:
    - resource_group_name: Name of the resource group (str)
    - account_name: Name of the media service account (str)
    - parameters: Edge policy listing parameters (ListEdgePoliciesInput)
    
    Returns:
    EdgePolicies containing policy configurations
    """

class MediaService:
    """Azure Media Services account resource."""
    name: str
    location: str
    resource_group: str
    tags: dict
    storage_accounts: List[StorageAccount]
    encryption: MediaServiceEncryption
    key_delivery: KeyDelivery
    public_network_access: str
    provisioning_state: str
    
class StorageAccount:
    """Storage account configuration for media service."""
    type: str  # Primary or Secondary
    id: str
    identity: MediaServiceIdentity
    
class SyncStorageKeysInput:
    """Parameters for storage key synchronization."""
    id: str
    
class ListEdgePoliciesInput:
    """Parameters for listing edge policies."""
    device_id: str
    
class EdgePolicies:
    """Edge policies configuration."""
    usage_data_collection_policy: EdgeUsageDataCollectionPolicy

from azure.mgmt.media import AzureMediaServices
from azure.mgmt.media.models import MediaService, StorageAccount
from azure.identity import DefaultAzureCredential

client = AzureMediaServices(
    credential=DefaultAzureCredential(),
    subscription_id="your-subscription-id"
)

# Configure storage account
storage_account = StorageAccount(
    type="Primary",
    id="/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.Storage/storageAccounts/storage"
)

# Create media service
media_service = MediaService(
    location="East US",
    storage_accounts=[storage_account]
)

# Start creation (long-running operation)
operation = client.mediaservices.begin_create_or_update(
    resource_group_name="my-resource-group",
    account_name="my-media-service",
    parameters=media_service
)

# Wait for completion
result = operation.result()
print(f"Media Service created: {result.name}")

# List all media services in a resource group
media_services = client.mediaservices.list("my-resource-group")

for service in media_services:
    print(f"Service: {service.name}")
    print(f"Location: {service.location}")
    print(f"Storage Accounts: {len(service.storage_accounts)}")
    
    # Sync storage keys if needed
    if service.storage_accounts:
        storage_id = service.storage_accounts[0].id
        sync_input = SyncStorageKeysInput(id=storage_id)
        
        client.mediaservices.sync_storage_keys(
            resource_group_name="my-resource-group",
            account_name=service.name,
            parameters=sync_input
        )
        print(f"Storage keys synchronized for {service.name}")