Service Operations

from azure.mgmt.maps.models import (
    OperationDetail, OperationDisplay, ServiceSpecification,
    MetricSpecification, Dimension, MapsOperations
)
from typing import Iterable, List, Optional

def list_operations(**kwargs) -> Iterable[OperationDetail]:
    """
    List available operations for Azure Maps management.
    
    Returns:
        Iterable[OperationDetail]: Iterator of available operations
        
    Usage:
        Operations include account management, creator management, 
        and service metadata operations.
    """

def list_subscription_operations(**kwargs) -> Iterable[OperationDetail]:
    """
    List operations available for the current subscription.
    
    Returns:
        Iterable[OperationDetail]: Iterator of subscription-specific operations
        
    Usage:
        May include subscription-level operations and resource provider
        registrations specific to the current subscription context.
    """

# Discover all available operations
operations = list(client.maps.list_operations())

print(f"Found {len(operations)} operations:")
for operation in operations:
    print(f"- {operation.name}: {operation.display.description}")
    if operation.display.provider:
        print(f"  Provider: {operation.display.provider}")
    if operation.display.resource:
        print(f"  Resource: {operation.display.resource}")
    print()

# Check subscription-specific operations
sub_operations = list(client.maps.list_subscription_operations())
print(f"Subscription operations: {len(sub_operations)}")

# Analyze operation capabilities
operation_categories = {}
for operation in client.maps.list_operations():
    category = operation.display.resource or "General"
    if category not in operation_categories:
        operation_categories[category] = []
    operation_categories[category].append(operation.display.operation)

print("Operations by category:")
for category, ops in operation_categories.items():
    print(f"{category}: {len(ops)} operations")
    for op in ops[:3]:  # Show first 3
        print(f"  - {op}")
    if len(ops) > 3:
        print(f"  ... and {len(ops) - 3} more")
    print()

class OperationDetail:
    """Detailed information about a service operation."""  
    # Operation identification
    name: Optional[str]  # Operation name (e.g., "Microsoft.Maps/accounts/read")
    is_data_action: Optional[bool]  # Whether this is a data plane operation
    
    # Human-readable information
    display: Optional[OperationDisplay]  # Display information
    
    # Service specifications
    service_specification: Optional[ServiceSpecification]  # Service capabilities
    origin: Optional[str]  # Operation origin
    action_type: Optional[str]  # Action type classification

class OperationDisplay:
    """Human-readable operation information."""
    provider: Optional[str]  # Resource provider (e.g., "Microsoft Maps")
    resource: Optional[str]  # Resource type (e.g., "Maps Account")
    operation: Optional[str]  # Operation description (e.g., "Read Maps Account")
    description: Optional[str]  # Detailed description

class ServiceSpecification:
    """Service capability and metric specifications."""
    metric_specifications: Optional[List[MetricSpecification]]  # Available metrics
    log_specifications: Optional[List[object]]  # Log specifications

class MetricSpecification:
    """Specification for service metrics.""" 
    # Metric identification
    name: Optional[str]  # Metric name
    display_name: Optional[str]  # Human-readable name
    display_description: Optional[str]  # Metric description
    
    # Metric properties
    unit: Optional[str]  # Metric unit (e.g., "Count", "Bytes")
    aggregation_type: Optional[str]  # Aggregation method
    dimensions: Optional[List[Dimension]]  # Metric dimensions
    
    # Availability
    fill_gap_with_zero: Optional[bool]  # Whether to fill gaps with zero
    category: Optional[str]  # Metric category
    resource_id_dimension_name_override: Optional[str]  # Resource ID dimension override

class Dimension:
    """Metric dimension specification."""
    name: Optional[str]  # Dimension name
    display_name: Optional[str]  # Human-readable name  
    internal_name: Optional[str]  # Internal dimension name
    to_be_exported_for_shoebox: Optional[bool]  # Export flag

class MapsOperations:
    """Collection of Maps operations."""
    value: Optional[List[OperationDetail]]  # List of operations
    next_link: Optional[str]  # Link to next page

# Find operations related to monitoring and metrics
monitoring_operations = []
for operation in client.maps.list_operations():
    if any(keyword in operation.name.lower() for keyword in ['metric', 'log', 'monitor', 'diagnos']):
        monitoring_operations.append(operation)

print(f"Found {len(monitoring_operations)} monitoring-related operations")

# Examine available metrics
for operation in client.maps.list_operations():
    if operation.service_specification and operation.service_specification.metric_specifications:
        print(f"Operation {operation.name} provides metrics:")
        for metric in operation.service_specification.metric_specifications:
            print(f"  - {metric.display_name}: {metric.display_description}")
            print(f"    Unit: {metric.unit}, Aggregation: {metric.aggregation_type}")

# Categorize operations by access level
read_operations = []
write_operations = []
delete_operations = []

for operation in client.maps.list_operations():
    op_name = operation.name.lower()
    if '/read' in op_name or 'list' in op_name or 'get' in op_name:
        read_operations.append(operation)
    elif '/delete' in op_name:
        delete_operations.append(operation)  
    elif '/write' in op_name or 'create' in op_name or 'update' in op_name:
        write_operations.append(operation)

print(f"Access patterns:")
print(f"  Read operations: {len(read_operations)}")
print(f"  Write operations: {len(write_operations)}")  
print(f"  Delete operations: {len(delete_operations)}")

# Show data actions vs management actions
data_actions = [op for op in client.maps.list_operations() if op.is_data_action]
mgmt_actions = [op for op in client.maps.list_operations() if not op.is_data_action]

print(f"\nAction types:")
print(f"  Management actions: {len(mgmt_actions)}")
print(f"  Data actions: {len(data_actions)}")

# Examine operation origins and features
origins = {}
for operation in client.maps.list_operations():
    origin = operation.origin or "Unknown"
    if origin not in origins:
        origins[origin] = []
    origins[origin].append(operation.name)

print("Operations by origin:")
for origin, ops in origins.items():
    print(f"  {origin}: {len(ops)} operations")

# Look for specific resource types
resource_types = set()
for operation in client.maps.list_operations():
    if operation.display and operation.display.resource:
        resource_types.add(operation.display.resource)

print(f"\nSupported resource types: {', '.join(sorted(resource_types))}")