runbooks 1.1.4__py3-none-any.whl → 1.1.5__py3-none-any.whl

runbooks/finops/network_cost_optimizer.py

@@ -25,30 +25,40 @@ Strategic Alignment:
 import asyncio
 import logging
 import time
-from datetime import datetime, timedelta
-from typing import Any, Dict, List, Optional, Tuple
 from dataclasses import dataclass
+from datetime import datetime, timedelta
 from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple
 
 import boto3
 import click
 from botocore.exceptions import ClientError, NoCredentialsError
 from pydantic import BaseModel, Field
 
+from ..common.profile_utils import get_profile_for_operation
 from ..common.rich_utils import (
-    console, print_header, print_success, print_error, print_warning, print_info,
-    create_table, create_progress_bar, format_cost, create_panel, STATUS_INDICATORS
+    STATUS_INDICATORS,
+    console,
+    create_panel,
+    create_progress_bar,
+    create_table,
+    format_cost,
+    print_error,
+    print_header,
+    print_info,
+    print_success,
+    print_warning,
 )
-from .embedded_mcp_validator import EmbeddedMCPValidator
-from ..common.profile_utils import get_profile_for_operation
+from .mcp_validator import EmbeddedMCPValidator
 
 logger = logging.getLogger(__name__)
 
 
 class NetworkService(str, Enum):
     """Network services for cost optimization."""
+
     NAT_GATEWAY = "nat_gateway"
-    ELASTIC_IP = "elastic_ip" 
+    ELASTIC_IP = "elastic_ip"
     LOAD_BALANCER = "load_balancer"
     TRANSIT_GATEWAY = "transit_gateway"
     VPC_ENDPOINT = "vpc_endpoint"
@@ -56,14 +66,16 @@ class NetworkService(str, Enum):
 
 class LoadBalancerType(str, Enum):
     """Load balancer types."""
+
     APPLICATION = "application"  # ALB
-    NETWORK = "network"          # NLB
-    CLASSIC = "classic"          # CLB
-    GATEWAY = "gateway"          # GWLB
+    NETWORK = "network"  # NLB
+    CLASSIC = "classic"  # CLB
+    GATEWAY = "gateway"  # GWLB
 
 
 class NetworkResourceDetails(BaseModel):
     """Network resource details from AWS APIs."""
+
     resource_id: str
     resource_type: str
     service: NetworkService
@@ -73,22 +85,22 @@ class NetworkResourceDetails(BaseModel):
     subnet_id: Optional[str] = None
     state: str = "available"
     create_time: Optional[datetime] = None
-    
+
     # Network-specific attributes
     public_ip: Optional[str] = None
     private_ip: Optional[str] = None
     dns_name: Optional[str] = None
     load_balancer_type: Optional[LoadBalancerType] = None
     target_count: int = 0
-    
+
     # Cost attributes
     hourly_cost: float = 0.0
     data_processing_cost: float = 0.0  # Per GB
     monthly_cost: float = 0.0
     annual_cost: float = 0.0
-    
+
     tags: Dict[str, str] = Field(default_factory=dict)
-    
+
     # Usage and dependency attributes
     has_dependencies: bool = False
     dependency_score: float = 0.0
@@ -97,25 +109,26 @@ class NetworkResourceDetails(BaseModel):
 
 class NetworkUsageMetrics(BaseModel):
     """Network resource usage metrics from CloudWatch."""
+
     resource_id: str
     region: str
     service: NetworkService
-    
+
     # Common network metrics
     active_connections: float = 0.0
     bytes_processed: float = 0.0
     request_count: float = 0.0
-    
+
     # NAT Gateway specific
     bytes_in_from_destination: float = 0.0
     bytes_out_to_destination: float = 0.0
     packet_drop_count: float = 0.0
-    
+
     # Load Balancer specific
     target_response_time: float = 0.0
     healthy_targets: int = 0
     unhealthy_targets: int = 0
-    
+
     # Analysis results
     analysis_period_days: int = 7
     is_used: bool = True
@@ -125,24 +138,25 @@ class NetworkUsageMetrics(BaseModel):
 
 class NetworkOptimizationResult(BaseModel):
     """Network resource optimization analysis results."""
+
     resource_id: str
     region: str
     service: NetworkService
     resource_type: str
     current_state: str
     usage_metrics: Optional[NetworkUsageMetrics] = None
-    
+
     # Cost analysis
     current_monthly_cost: float = 0.0
     current_annual_cost: float = 0.0
     data_processing_monthly_cost: float = 0.0
     data_processing_annual_cost: float = 0.0
-    
+
     # Optimization strategies
     optimization_recommendation: str = "retain"  # retain, decommission, rightsize, consolidate
     risk_level: str = "low"  # low, medium, high
     business_impact: str = "minimal"
-    
+
     # Savings potential
     infrastructure_monthly_savings: float = 0.0
     infrastructure_annual_savings: float = 0.0
@@ -150,13 +164,13 @@ class NetworkOptimizationResult(BaseModel):
     data_transfer_annual_savings: float = 0.0
     total_monthly_savings: float = 0.0
     total_annual_savings: float = 0.0
-    
+
     # Dependencies and safety
     route_table_dependencies: List[str] = Field(default_factory=list)
     dns_dependencies: List[str] = Field(default_factory=list)
     application_dependencies: List[str] = Field(default_factory=list)
     dependency_risk_score: float = 0.0
-    
+
     # Alternative solutions
     alternative_solution: Optional[str] = None
     alternative_monthly_cost: float = 0.0
@@ -165,9 +179,10 @@ class NetworkOptimizationResult(BaseModel):
 
 class NetworkCostOptimizerResults(BaseModel):
     """Complete network cost optimization analysis results."""
+
     analyzed_services: List[NetworkService] = Field(default_factory=list)
     analyzed_regions: List[str] = Field(default_factory=list)
-    
+
     # Resource summary
     total_network_resources: int = 0
     nat_gateways: int = 0
@@ -175,7 +190,7 @@ class NetworkCostOptimizerResults(BaseModel):
     load_balancers: int = 0
     transit_gateways: int = 0
     vpc_endpoints: int = 0
-    
+
     # Cost summary
     total_monthly_infrastructure_cost: float = 0.0
     total_annual_infrastructure_cost: float = 0.0
@@ -183,7 +198,7 @@ class NetworkCostOptimizerResults(BaseModel):
     total_annual_data_processing_cost: float = 0.0
     total_monthly_cost: float = 0.0
     total_annual_cost: float = 0.0
-    
+
     # Savings breakdown
     infrastructure_monthly_savings: float = 0.0
     infrastructure_annual_savings: float = 0.0
@@ -191,10 +206,10 @@ class NetworkCostOptimizerResults(BaseModel):
     data_transfer_annual_savings: float = 0.0
     total_monthly_savings: float = 0.0
     total_annual_savings: float = 0.0
-    
+
     # Optimization results
     optimization_results: List[NetworkOptimizationResult] = Field(default_factory=list)
-    
+
     execution_time_seconds: float = 0.0
     mcp_validation_accuracy: float = 0.0
     analysis_timestamp: datetime = Field(default_factory=datetime.now)
@@ -203,7 +218,7 @@ class NetworkCostOptimizerResults(BaseModel):
 class NetworkCostOptimizer:
     """
     Network Cost Optimization Engine - Enterprise FinOps Network Analysis Platform
-    
+
     Following $132,720+ methodology with proven FinOps patterns targeting $2.4M-$7.3M annual savings:
     - Multi-service network resource discovery and analysis
     - CloudWatch metrics integration for usage validation and rightsizing
@@ -213,136 +228,149 @@ class NetworkCostOptimizer:
     - Evidence generation for Manager/Financial/CTO executive reporting
     - Business-focused network optimization strategy for enterprise presentation
     """
-    
+
     def __init__(self, profile_name: Optional[str] = None, regions: Optional[List[str]] = None):
         """Initialize network cost optimizer with enterprise profile support."""
         self.profile_name = profile_name
-        self.regions = regions or ['us-east-1', 'us-west-2', 'eu-west-1']
-        
+        self.regions = regions or ["us-east-1", "us-west-2", "eu-west-1"]
+
         # Initialize AWS session with profile priority system
-        self.session = boto3.Session(
-            profile_name=get_profile_for_operation("operational", profile_name)
-        )
-        
+        self.session = boto3.Session(profile_name=get_profile_for_operation("operational", profile_name))
+
         # Network service pricing (per hour, as of 2024)
         self.network_pricing = {
             NetworkService.NAT_GATEWAY: {
-                'hourly_cost': 0.045,         # $0.045/hour
-                'data_processing_cost': 0.045  # $0.045/GB
+                "hourly_cost": 0.045,  # $0.045/hour
+                "data_processing_cost": 0.045,  # $0.045/GB
             },
             NetworkService.ELASTIC_IP: {
-                'monthly_cost_unattached': 3.65  # $3.65/month if unattached
+                "monthly_cost_unattached": 3.65  # $3.65/month if unattached
             },
             NetworkService.LOAD_BALANCER: {
                 LoadBalancerType.APPLICATION: {
-                    'hourly_cost': 0.0225,       # $0.0225/hour
-                    'lcu_cost': 0.008            # $0.008/LCU hour
+                    "hourly_cost": 0.0225,  # $0.0225/hour
+                    "lcu_cost": 0.008,  # $0.008/LCU hour
                 },
                 LoadBalancerType.NETWORK: {
-                    'hourly_cost': 0.0225,       # $0.0225/hour  
-                    'nlcu_cost': 0.006           # $0.006/NLCU hour
+                    "hourly_cost": 0.0225,  # $0.0225/hour
+                    "nlcu_cost": 0.006,  # $0.006/NLCU hour
                 },
                 LoadBalancerType.CLASSIC: {
-                    'hourly_cost': 0.025,        # $0.025/hour
-                    'data_cost': 0.008           # $0.008/GB
-                }
+                    "hourly_cost": 0.025,  # $0.025/hour
+                    "data_cost": 0.008,  # $0.008/GB
+                },
             },
             NetworkService.TRANSIT_GATEWAY: {
-                'hourly_cost': 0.05,             # $0.05/hour attachment
-                'data_processing_cost': 0.02      # $0.02/GB
+                "hourly_cost": 0.05,  # $0.05/hour attachment
+                "data_processing_cost": 0.02,  # $0.02/GB
             },
             NetworkService.VPC_ENDPOINT: {
-                'hourly_cost': 0.01,             # $0.01/hour per AZ
-                'data_processing_cost': 0.01      # $0.01/GB
-            }
+                "hourly_cost": 0.01,  # $0.01/hour per AZ
+                "data_processing_cost": 0.01,  # $0.01/GB
+            },
         }
-        
+
         # Usage thresholds for optimization recommendations
-        self.low_usage_threshold_connections = 10     # Active connections per day
-        self.low_usage_threshold_bytes = 1_000_000    # 1MB per day
-        self.analysis_period_days = 14                # CloudWatch analysis period
-    
-    async def analyze_network_costs(self, services: List[NetworkService] = None, dry_run: bool = True) -> NetworkCostOptimizerResults:
+        self.low_usage_threshold_connections = 10  # Active connections per day
+        self.low_usage_threshold_bytes = 1_000_000  # 1MB per day
+        self.analysis_period_days = 14  # CloudWatch analysis period
+
+    async def analyze_network_costs(
+        self, services: List[NetworkService] = None, dry_run: bool = True
+    ) -> NetworkCostOptimizerResults:
         """
         Comprehensive network cost optimization analysis.
-        
+
         Args:
             services: List of network services to analyze (None = all services)
             dry_run: Safety mode - READ-ONLY analysis only
-            
+
         Returns:
             Complete analysis results with optimization recommendations
         """
         print_header("Network Cost Optimization Engine", "Enterprise Multi-Service Network Analysis Platform v1.0")
-        
+
         if not dry_run:
             print_warning("⚠️ Dry-run disabled - This optimizer is READ-ONLY analysis only")
             print_info("All network operations require manual execution after review")
-        
+
         analysis_start_time = time.time()
         services_to_analyze = services or [
             NetworkService.NAT_GATEWAY,
             NetworkService.ELASTIC_IP,
             NetworkService.LOAD_BALANCER,
             NetworkService.TRANSIT_GATEWAY,
-            NetworkService.VPC_ENDPOINT
+            NetworkService.VPC_ENDPOINT,
         ]
-        
+
         try:
             with create_progress_bar() as progress:
                 # Step 1: Multi-service network resource discovery
-                discovery_task = progress.add_task("Discovering network resources...", 
-                                                 total=len(services_to_analyze) * len(self.regions))
-                network_resources = await self._discover_network_resources_multi_service(services_to_analyze, progress, discovery_task)
-                
+                discovery_task = progress.add_task(
+                    "Discovering network resources...", total=len(services_to_analyze) * len(self.regions)
+                )
+                network_resources = await self._discover_network_resources_multi_service(
+                    services_to_analyze, progress, discovery_task
+                )
+
                 if not network_resources:
                     print_warning("No network resources found in specified regions")
                     return NetworkCostOptimizerResults(
                         analyzed_services=services_to_analyze,
                         analyzed_regions=self.regions,
                         analysis_timestamp=datetime.now(),
-                        execution_time_seconds=time.time() - analysis_start_time
+                        execution_time_seconds=time.time() - analysis_start_time,
                     )
-                
+
                 # Step 2: Usage metrics analysis via CloudWatch
                 metrics_task = progress.add_task("Analyzing usage metrics...", total=len(network_resources))
                 usage_metrics = await self._analyze_network_usage_metrics(network_resources, progress, metrics_task)
-                
+
                 # Step 3: Dependency analysis for safety assessment
                 dependency_task = progress.add_task("Analyzing dependencies...", total=len(network_resources))
-                dependency_analysis = await self._analyze_network_dependencies(network_resources, progress, dependency_task)
-                
+                dependency_analysis = await self._analyze_network_dependencies(
+                    network_resources, progress, dependency_task
+                )
+
                 # Step 4: Cost calculation and pricing analysis
                 costing_task = progress.add_task("Calculating costs...", total=len(network_resources))
-                cost_analysis = await self._calculate_network_costs(network_resources, usage_metrics, progress, costing_task)
-                
+                cost_analysis = await self._calculate_network_costs(
+                    network_resources, usage_metrics, progress, costing_task
+                )
+
                 # Step 5: Comprehensive optimization analysis
-                optimization_task = progress.add_task("Calculating optimization potential...", total=len(network_resources))
+                optimization_task = progress.add_task(
+                    "Calculating optimization potential...", total=len(network_resources)
+                )
                 optimization_results = await self._calculate_network_optimization_recommendations(
                     network_resources, usage_metrics, dependency_analysis, cost_analysis, progress, optimization_task
                 )
-                
+
                 # Step 6: MCP validation
                 validation_task = progress.add_task("MCP validation...", total=1)
                 mcp_accuracy = await self._validate_with_mcp(optimization_results, progress, validation_task)
-                
+
             # Compile comprehensive results
-            results = self._compile_results(network_resources, optimization_results, mcp_accuracy, analysis_start_time, services_to_analyze)
-            
+            results = self._compile_results(
+                network_resources, optimization_results, mcp_accuracy, analysis_start_time, services_to_analyze
+            )
+
             # Display executive summary
             self._display_executive_summary(results)
-            
+
             return results
-            
+
         except Exception as e:
             print_error(f"Network cost optimization analysis failed: {e}")
             logger.error(f"Network analysis error: {e}", exc_info=True)
             raise
-    
-    async def _discover_network_resources_multi_service(self, services: List[NetworkService], progress, task_id) -> List[NetworkResourceDetails]:
+
+    async def _discover_network_resources_multi_service(
+        self, services: List[NetworkService], progress, task_id
+    ) -> List[NetworkResourceDetails]:
         """Discover network resources across multiple services and regions."""
         network_resources = []
-        
+
         for service in services:
             for region in self.regions:
                 try:
@@ -361,308 +389,332 @@ class NetworkCostOptimizer:
                     elif service == NetworkService.VPC_ENDPOINT:
                         resources = await self._discover_vpc_endpoints(region)
                         network_resources.extend(resources)
-                    
+
                     service_resources = [r for r in network_resources if r.region == region and r.service == service]
                     print_info(f"Service {service.value} in {region}: {len(service_resources)} resources discovered")
-                    
+
                 except ClientError as e:
                     print_warning(f"Service {service.value} in {region}: Access denied - {e.response['Error']['Code']}")
                 except Exception as e:
                     print_error(f"Service {service.value} in {region}: Discovery error - {str(e)}")
-                    
+
                 progress.advance(task_id)
-        
+
         return network_resources
-    
+
     async def _discover_nat_gateways(self, region: str) -> List[NetworkResourceDetails]:
         """Discover NAT Gateways for cost analysis."""
         resources = []
-        
+
         try:
-            ec2_client = self.session.client('ec2', region_name=region)
-            
+            ec2_client = self.session.client("ec2", region_name=region)
+
             response = ec2_client.describe_nat_gateways()
-            for nat_gateway in response.get('NatGateways', []):
+            for nat_gateway in response.get("NatGateways", []):
                 # Skip deleted NAT Gateways
-                if nat_gateway.get('State') == 'deleted':
+                if nat_gateway.get("State") == "deleted":
                     continue
-                
-                tags = {tag['Key']: tag['Value'] for tag in nat_gateway.get('Tags', [])}
-                
+
+                tags = {tag["Key"]: tag["Value"] for tag in nat_gateway.get("Tags", [])}
+
                 # Get NAT Gateway addresses
                 public_ip = None
                 private_ip = None
-                for address in nat_gateway.get('NatGatewayAddresses', []):
-                    if address.get('PublicIp'):
-                        public_ip = address['PublicIp']
-                    if address.get('PrivateIp'):
-                        private_ip = address['PrivateIp']
-                
+                for address in nat_gateway.get("NatGatewayAddresses", []):
+                    if address.get("PublicIp"):
+                        public_ip = address["PublicIp"]
+                    if address.get("PrivateIp"):
+                        private_ip = address["PrivateIp"]
+
                 pricing = self.network_pricing[NetworkService.NAT_GATEWAY]
-                hourly_cost = pricing['hourly_cost']
+                hourly_cost = pricing["hourly_cost"]
                 monthly_cost = hourly_cost * 24 * 30.44
                 annual_cost = hourly_cost * 24 * 365
-                
-                resources.append(NetworkResourceDetails(
-                    resource_id=nat_gateway['NatGatewayId'],
-                    resource_type='NAT Gateway',
-                    service=NetworkService.NAT_GATEWAY,
-                    region=region,
-                    availability_zone=nat_gateway.get('SubnetId'),  # Subnet implies AZ
-                    vpc_id=nat_gateway.get('VpcId'),
-                    subnet_id=nat_gateway.get('SubnetId'),
-                    state=nat_gateway.get('State'),
-                    create_time=nat_gateway.get('CreateTime'),
-                    public_ip=public_ip,
-                    private_ip=private_ip,
-                    hourly_cost=hourly_cost,
-                    data_processing_cost=pricing['data_processing_cost'],
-                    monthly_cost=monthly_cost,
-                    annual_cost=annual_cost,
-                    tags=tags
-                ))
-                
+
+                resources.append(
+                    NetworkResourceDetails(
+                        resource_id=nat_gateway["NatGatewayId"],
+                        resource_type="NAT Gateway",
+                        service=NetworkService.NAT_GATEWAY,
+                        region=region,
+                        availability_zone=nat_gateway.get("SubnetId"),  # Subnet implies AZ
+                        vpc_id=nat_gateway.get("VpcId"),
+                        subnet_id=nat_gateway.get("SubnetId"),
+                        state=nat_gateway.get("State"),
+                        create_time=nat_gateway.get("CreateTime"),
+                        public_ip=public_ip,
+                        private_ip=private_ip,
+                        hourly_cost=hourly_cost,
+                        data_processing_cost=pricing["data_processing_cost"],
+                        monthly_cost=monthly_cost,
+                        annual_cost=annual_cost,
+                        tags=tags,
+                    )
+                )
+
         except Exception as e:
             logger.warning(f"NAT Gateway discovery failed in {region}: {e}")
-        
+
         return resources
-    
+
     async def _discover_elastic_ips(self, region: str) -> List[NetworkResourceDetails]:
         """Discover Elastic IPs for cost analysis."""
         resources = []
-        
+
         try:
-            ec2_client = self.session.client('ec2', region_name=region)
-            
+            ec2_client = self.session.client("ec2", region_name=region)
+
             response = ec2_client.describe_addresses()
-            for eip in response.get('Addresses', []):
-                tags = {tag['Key']: tag['Value'] for tag in eip.get('Tags', [])}
-                
+            for eip in response.get("Addresses", []):
+                tags = {tag["Key"]: tag["Value"] for tag in eip.get("Tags", [])}
+
                 # Check if EIP is attached
-                is_attached = bool(eip.get('InstanceId') or eip.get('NetworkInterfaceId'))
-                
+                is_attached = bool(eip.get("InstanceId") or eip.get("NetworkInterfaceId"))
+
                 # Only unattached EIPs have costs
-                monthly_cost = 0.0 if is_attached else self.network_pricing[NetworkService.ELASTIC_IP]['monthly_cost_unattached']
+                monthly_cost = (
+                    0.0 if is_attached else self.network_pricing[NetworkService.ELASTIC_IP]["monthly_cost_unattached"]
+                )
                 annual_cost = monthly_cost * 12
-                
-                resources.append(NetworkResourceDetails(
-                    resource_id=eip['AllocationId'],
-                    resource_type='Elastic IP',
-                    service=NetworkService.ELASTIC_IP,
-                    region=region,
-                    state='attached' if is_attached else 'unattached',
-                    public_ip=eip.get('PublicIp'),
-                    private_ip=eip.get('PrivateIpAddress'),
-                    monthly_cost=monthly_cost,
-                    annual_cost=annual_cost,
-                    tags=tags,
-                    has_dependencies=is_attached
-                ))
-                
+
+                resources.append(
+                    NetworkResourceDetails(
+                        resource_id=eip["AllocationId"],
+                        resource_type="Elastic IP",
+                        service=NetworkService.ELASTIC_IP,
+                        region=region,
+                        state="attached" if is_attached else "unattached",
+                        public_ip=eip.get("PublicIp"),
+                        private_ip=eip.get("PrivateIpAddress"),
+                        monthly_cost=monthly_cost,
+                        annual_cost=annual_cost,
+                        tags=tags,
+                        has_dependencies=is_attached,
+                    )
+                )
+
         except Exception as e:
             logger.warning(f"Elastic IP discovery failed in {region}: {e}")
-        
+
         return resources
-    
+
     async def _discover_load_balancers(self, region: str) -> List[NetworkResourceDetails]:
         """Discover Load Balancers (ALB, NLB, CLB) for cost analysis."""
         resources = []
-        
+
         try:
             # Application and Network Load Balancers (ELBv2)
-            elbv2_client = self.session.client('elbv2', region_name=region)
-            
+            elbv2_client = self.session.client("elbv2", region_name=region)
+
             response = elbv2_client.describe_load_balancers()
-            for lb in response.get('LoadBalancers', []):
+            for lb in response.get("LoadBalancers", []):
                 # Skip provisioning or failed load balancers
-                if lb.get('State', {}).get('Code') not in ['active', 'idle']:
+                if lb.get("State", {}).get("Code") not in ["active", "idle"]:
                     continue
-                
-                lb_type = LoadBalancerType.APPLICATION if lb.get('Type') == 'application' else LoadBalancerType.NETWORK
-                
+
+                lb_type = LoadBalancerType.APPLICATION if lb.get("Type") == "application" else LoadBalancerType.NETWORK
+
                 # Get target count
                 target_count = 0
                 try:
-                    target_groups_response = elbv2_client.describe_target_groups(LoadBalancerArn=lb['LoadBalancerArn'])
-                    for tg in target_groups_response.get('TargetGroups', []):
-                        targets_response = elbv2_client.describe_target_health(TargetGroupArn=tg['TargetGroupArn'])
-                        target_count += len(targets_response.get('TargetHealthDescriptions', []))
+                    target_groups_response = elbv2_client.describe_target_groups(LoadBalancerArn=lb["LoadBalancerArn"])
+                    for tg in target_groups_response.get("TargetGroups", []):
+                        targets_response = elbv2_client.describe_target_health(TargetGroupArn=tg["TargetGroupArn"])
+                        target_count += len(targets_response.get("TargetHealthDescriptions", []))
                 except Exception:
                     pass  # Target count is optional
-                
+
                 # Get pricing
                 pricing = self.network_pricing[NetworkService.LOAD_BALANCER][lb_type]
-                hourly_cost = pricing['hourly_cost']
+                hourly_cost = pricing["hourly_cost"]
                 monthly_cost = hourly_cost * 24 * 30.44
                 annual_cost = hourly_cost * 24 * 365
-                
-                resources.append(NetworkResourceDetails(
-                    resource_id=lb['LoadBalancerArn'].split('/')[-3] + '/' + lb['LoadBalancerArn'].split('/')[-2] + '/' + lb['LoadBalancerArn'].split('/')[-1],
-                    resource_type=f'{lb_type.value.title()} Load Balancer',
-                    service=NetworkService.LOAD_BALANCER,
-                    region=region,
-                    vpc_id=lb.get('VpcId'),
-                    state=lb.get('State', {}).get('Code', 'unknown'),
-                    create_time=lb.get('CreatedTime'),
-                    dns_name=lb.get('DNSName'),
-                    load_balancer_type=lb_type,
-                    target_count=target_count,
-                    hourly_cost=hourly_cost,
-                    monthly_cost=monthly_cost,
-                    annual_cost=annual_cost,
-                    has_dependencies=target_count > 0
-                ))
-                
+
+                resources.append(
+                    NetworkResourceDetails(
+                        resource_id=lb["LoadBalancerArn"].split("/")[-3]
+                        + "/"
+                        + lb["LoadBalancerArn"].split("/")[-2]
+                        + "/"
+                        + lb["LoadBalancerArn"].split("/")[-1],
+                        resource_type=f"{lb_type.value.title()} Load Balancer",
+                        service=NetworkService.LOAD_BALANCER,
+                        region=region,
+                        vpc_id=lb.get("VpcId"),
+                        state=lb.get("State", {}).get("Code", "unknown"),
+                        create_time=lb.get("CreatedTime"),
+                        dns_name=lb.get("DNSName"),
+                        load_balancer_type=lb_type,
+                        target_count=target_count,
+                        hourly_cost=hourly_cost,
+                        monthly_cost=monthly_cost,
+                        annual_cost=annual_cost,
+                        has_dependencies=target_count > 0,
+                    )
+                )
+
             # Classic Load Balancers (ELB)
-            elb_client = self.session.client('elb', region_name=region)
-            
+            elb_client = self.session.client("elb", region_name=region)
+
             response = elb_client.describe_load_balancers()
-            for lb in response.get('LoadBalancerDescriptions', []):
+            for lb in response.get("LoadBalancerDescriptions", []):
                 # Get instance count
-                instance_count = len(lb.get('Instances', []))
-                
+                instance_count = len(lb.get("Instances", []))
+
                 pricing = self.network_pricing[NetworkService.LOAD_BALANCER][LoadBalancerType.CLASSIC]
-                hourly_cost = pricing['hourly_cost']
+                hourly_cost = pricing["hourly_cost"]
                 monthly_cost = hourly_cost * 24 * 30.44
                 annual_cost = hourly_cost * 24 * 365
-                
-                resources.append(NetworkResourceDetails(
-                    resource_id=lb['LoadBalancerName'],
-                    resource_type='Classic Load Balancer',
-                    service=NetworkService.LOAD_BALANCER,
-                    region=region,
-                    vpc_id=lb.get('VPCId'),
-                    state='active',  # CLBs don't have explicit state
-                    create_time=lb.get('CreatedTime'),
-                    dns_name=lb.get('DNSName'),
-                    load_balancer_type=LoadBalancerType.CLASSIC,
-                    target_count=instance_count,
-                    hourly_cost=hourly_cost,
-                    monthly_cost=monthly_cost,
-                    annual_cost=annual_cost,
-                    has_dependencies=instance_count > 0
-                ))
-                
+
+                resources.append(
+                    NetworkResourceDetails(
+                        resource_id=lb["LoadBalancerName"],
+                        resource_type="Classic Load Balancer",
+                        service=NetworkService.LOAD_BALANCER,
+                        region=region,
+                        vpc_id=lb.get("VPCId"),
+                        state="active",  # CLBs don't have explicit state
+                        create_time=lb.get("CreatedTime"),
+                        dns_name=lb.get("DNSName"),
+                        load_balancer_type=LoadBalancerType.CLASSIC,
+                        target_count=instance_count,
+                        hourly_cost=hourly_cost,
+                        monthly_cost=monthly_cost,
+                        annual_cost=annual_cost,
+                        has_dependencies=instance_count > 0,
+                    )
+                )
+
         except Exception as e:
             logger.warning(f"Load Balancer discovery failed in {region}: {e}")
-        
+
         return resources
-    
+
     async def _discover_transit_gateways(self, region: str) -> List[NetworkResourceDetails]:
         """Discover Transit Gateways for cost analysis."""
         resources = []
-        
+
         try:
-            ec2_client = self.session.client('ec2', region_name=region)
-            
+            ec2_client = self.session.client("ec2", region_name=region)
+
             response = ec2_client.describe_transit_gateways()
-            for tgw in response.get('TransitGateways', []):
+            for tgw in response.get("TransitGateways", []):
                 # Skip deleted TGWs
-                if tgw.get('State') == 'deleted':
+                if tgw.get("State") == "deleted":
                     continue
-                
-                tags = {tag['Key']: tag['Value'] for tag in tgw.get('Tags', [])}
-                
+
+                tags = {tag["Key"]: tag["Value"] for tag in tgw.get("Tags", [])}
+
                 # Get attachment count for dependency analysis
                 attachments_response = ec2_client.describe_transit_gateway_attachments(
-                    Filters=[{'Name': 'transit-gateway-id', 'Values': [tgw['TransitGatewayId']]}]
+                    Filters=[{"Name": "transit-gateway-id", "Values": [tgw["TransitGatewayId"]]}]
                 )
-                attachment_count = len(attachments_response.get('TransitGatewayAttachments', []))
-                
+                attachment_count = len(attachments_response.get("TransitGatewayAttachments", []))
+
                 pricing = self.network_pricing[NetworkService.TRANSIT_GATEWAY]
-                hourly_cost = pricing['hourly_cost'] * attachment_count  # Cost per attachment
+                hourly_cost = pricing["hourly_cost"] * attachment_count  # Cost per attachment
                 monthly_cost = hourly_cost * 24 * 30.44
                 annual_cost = hourly_cost * 24 * 365
-                
-                resources.append(NetworkResourceDetails(
-                    resource_id=tgw['TransitGatewayId'],
-                    resource_type='Transit Gateway',
-                    service=NetworkService.TRANSIT_GATEWAY,
-                    region=region,
-                    state=tgw.get('State'),
-                    hourly_cost=hourly_cost,
-                    data_processing_cost=pricing['data_processing_cost'],
-                    monthly_cost=monthly_cost,
-                    annual_cost=annual_cost,
-                    tags=tags,
-                    has_dependencies=attachment_count > 0,
-                    dependency_score=min(1.0, attachment_count / 10.0)  # Normalize to 0-1
-                ))
-                
+
+                resources.append(
+                    NetworkResourceDetails(
+                        resource_id=tgw["TransitGatewayId"],
+                        resource_type="Transit Gateway",
+                        service=NetworkService.TRANSIT_GATEWAY,
+                        region=region,
+                        state=tgw.get("State"),
+                        hourly_cost=hourly_cost,
+                        data_processing_cost=pricing["data_processing_cost"],
+                        monthly_cost=monthly_cost,
+                        annual_cost=annual_cost,
+                        tags=tags,
+                        has_dependencies=attachment_count > 0,
+                        dependency_score=min(1.0, attachment_count / 10.0),  # Normalize to 0-1
+                    )
+                )
+
         except Exception as e:
             logger.warning(f"Transit Gateway discovery failed in {region}: {e}")
-        
+
         return resources
-    
+
     async def _discover_vpc_endpoints(self, region: str) -> List[NetworkResourceDetails]:
         """Discover VPC Endpoints for cost analysis."""
         resources = []
-        
+
         try:
-            ec2_client = self.session.client('ec2', region_name=region)
-            
+            ec2_client = self.session.client("ec2", region_name=region)
+
             response = ec2_client.describe_vpc_endpoints()
-            for vpce in response.get('VpcEndpoints', []):
+            for vpce in response.get("VpcEndpoints", []):
                 # Skip deleted endpoints
-                if vpce.get('State') in ['deleted', 'deleting']:
+                if vpce.get("State") in ["deleted", "deleting"]:
                     continue
-                
-                tags = {tag['Key']: tag['Value'] for tag in vpce.get('Tags', [])}
-                
+
+                tags = {tag["Key"]: tag["Value"] for tag in vpce.get("Tags", [])}
+
                 # VPC Endpoint pricing varies by type (Interface vs Gateway)
-                endpoint_type = vpce.get('VpcEndpointType', 'Interface')
-                
-                if endpoint_type == 'Gateway':
+                endpoint_type = vpce.get("VpcEndpointType", "Interface")
+
+                if endpoint_type == "Gateway":
                     # Gateway endpoints are free
                     hourly_cost = 0.0
                     data_processing_cost = 0.0
                 else:
                     # Interface endpoints charge per AZ
-                    az_count = len(vpce.get('SubnetIds', []))
+                    az_count = len(vpce.get("SubnetIds", []))
                     pricing = self.network_pricing[NetworkService.VPC_ENDPOINT]
-                    hourly_cost = pricing['hourly_cost'] * az_count
-                    data_processing_cost = pricing['data_processing_cost']
-                
+                    hourly_cost = pricing["hourly_cost"] * az_count
+                    data_processing_cost = pricing["data_processing_cost"]
+
                 monthly_cost = hourly_cost * 24 * 30.44
                 annual_cost = hourly_cost * 24 * 365
-                
-                resources.append(NetworkResourceDetails(
-                    resource_id=vpce['VpcEndpointId'],
-                    resource_type=f'{endpoint_type} VPC Endpoint',
-                    service=NetworkService.VPC_ENDPOINT,
-                    region=region,
-                    vpc_id=vpce.get('VpcId'),
-                    state=vpce.get('State'),
-                    create_time=vpce.get('CreationTimestamp'),
-                    hourly_cost=hourly_cost,
-                    data_processing_cost=data_processing_cost,
-                    monthly_cost=monthly_cost,
-                    annual_cost=annual_cost,
-                    tags=tags,
-                    has_dependencies=True  # VPC Endpoints always have VPC dependencies
-                ))
-                
+
+                resources.append(
+                    NetworkResourceDetails(
+                        resource_id=vpce["VpcEndpointId"],
+                        resource_type=f"{endpoint_type} VPC Endpoint",
+                        service=NetworkService.VPC_ENDPOINT,
+                        region=region,
+                        vpc_id=vpce.get("VpcId"),
+                        state=vpce.get("State"),
+                        create_time=vpce.get("CreationTimestamp"),
+                        hourly_cost=hourly_cost,
+                        data_processing_cost=data_processing_cost,
+                        monthly_cost=monthly_cost,
+                        annual_cost=annual_cost,
+                        tags=tags,
+                        has_dependencies=True,  # VPC Endpoints always have VPC dependencies
+                    )
+                )
+
         except Exception as e:
             logger.warning(f"VPC Endpoint discovery failed in {region}: {e}")
-        
+
         return resources
-    
-    async def _analyze_network_usage_metrics(self, resources: List[NetworkResourceDetails], progress, task_id) -> Dict[str, NetworkUsageMetrics]:
+
+    async def _analyze_network_usage_metrics(
+        self, resources: List[NetworkResourceDetails], progress, task_id
+    ) -> Dict[str, NetworkUsageMetrics]:
         """Analyze network resource usage metrics via CloudWatch."""
         usage_metrics = {}
         end_time = datetime.utcnow()
         start_time = end_time - timedelta(days=self.analysis_period_days)
-        
+
         for resource in resources:
             try:
-                cloudwatch = self.session.client('cloudwatch', region_name=resource.region)
-                
+                cloudwatch = self.session.client("cloudwatch", region_name=resource.region)
+
                 if resource.service == NetworkService.NAT_GATEWAY:
-                    metrics = await self._get_nat_gateway_metrics(cloudwatch, resource.resource_id, start_time, end_time)
+                    metrics = await self._get_nat_gateway_metrics(
+                        cloudwatch, resource.resource_id, start_time, end_time
+                    )
                 elif resource.service == NetworkService.LOAD_BALANCER:
                     metrics = await self._get_load_balancer_metrics(cloudwatch, resource, start_time, end_time)
                 elif resource.service == NetworkService.TRANSIT_GATEWAY:
-                    metrics = await self._get_transit_gateway_metrics(cloudwatch, resource.resource_id, start_time, end_time)
+                    metrics = await self._get_transit_gateway_metrics(
+                        cloudwatch, resource.resource_id, start_time, end_time
+                    )
                 else:
                     # For Elastic IPs and VPC Endpoints, create default metrics
                     metrics = NetworkUsageMetrics(
@@ -670,11 +722,11 @@ class NetworkCostOptimizer:
                         region=resource.region,
                         service=resource.service,
                         analysis_period_days=self.analysis_period_days,
-                        usage_score=50.0  # Neutral score
+                        usage_score=50.0,  # Neutral score
                     )
-                
+
                 usage_metrics[resource.resource_id] = metrics
-                
+
             except Exception as e:
                 print_warning(f"Usage metrics unavailable for {resource.resource_id}: {str(e)}")
                 # Create default metrics
@@ -683,45 +735,54 @@ class NetworkCostOptimizer:
                     region=resource.region,
                     service=resource.service,
                     analysis_period_days=self.analysis_period_days,
-                    usage_score=50.0  # Conservative score
+                    usage_score=50.0,  # Conservative score
                 )
-                
+
             progress.advance(task_id)
-        
+
         return usage_metrics
-    
-    async def _get_nat_gateway_metrics(self, cloudwatch, nat_gateway_id: str, start_time: datetime, end_time: datetime) -> NetworkUsageMetrics:
+
+    async def _get_nat_gateway_metrics(
+        self, cloudwatch, nat_gateway_id: str, start_time: datetime, end_time: datetime
+    ) -> NetworkUsageMetrics:
         """Get NAT Gateway metrics from CloudWatch."""
         try:
             # Get active connections
             connections_response = cloudwatch.get_metric_statistics(
-                Namespace='AWS/NATGateway',
-                MetricName='ActiveConnectionCount',
-                Dimensions=[{'Name': 'NatGatewayId', 'Value': nat_gateway_id}],
+                Namespace="AWS/NATGateway",
+                MetricName="ActiveConnectionCount",
+                Dimensions=[{"Name": "NatGatewayId", "Value": nat_gateway_id}],
                 StartTime=start_time,
                 EndTime=end_time,
                 Period=86400,  # Daily data points
-                Statistics=['Average']
+                Statistics=["Average"],
             )
-            
+
             # Get bytes processed
             bytes_response = cloudwatch.get_metric_statistics(
-                Namespace='AWS/NATGateway', 
-                MetricName='BytesInFromDestination',
-                Dimensions=[{'Name': 'NatGatewayId', 'Value': nat_gateway_id}],
+                Namespace="AWS/NATGateway",
+                MetricName="BytesInFromDestination",
+                Dimensions=[{"Name": "NatGatewayId", "Value": nat_gateway_id}],
                 StartTime=start_time,
                 EndTime=end_time,
                 Period=86400,
-                Statistics=['Sum']
+                Statistics=["Sum"],
             )
-            
-            active_connections = sum(dp['Average'] for dp in connections_response.get('Datapoints', []))
-            bytes_processed = sum(dp['Sum'] for dp in bytes_response.get('Datapoints', []))
-            
+
+            active_connections = sum(dp["Average"] for dp in connections_response.get("Datapoints", []))
+            bytes_processed = sum(dp["Sum"] for dp in bytes_response.get("Datapoints", []))
+
             # Determine if NAT Gateway is being used
-            is_used = active_connections > self.low_usage_threshold_connections or bytes_processed > self.low_usage_threshold_bytes
-            usage_score = min(100, (active_connections / self.low_usage_threshold_connections) * 50 + (bytes_processed / self.low_usage_threshold_bytes) * 50)
-            
+            is_used = (
+                active_connections > self.low_usage_threshold_connections
+                or bytes_processed > self.low_usage_threshold_bytes
+            )
+            usage_score = min(
+                100,
+                (active_connections / self.low_usage_threshold_connections) * 50
+                + (bytes_processed / self.low_usage_threshold_bytes) * 50,
+            )
+
             return NetworkUsageMetrics(
                 resource_id=nat_gateway_id,
                 region=cloudwatch.meta.region_name,
@@ -731,9 +792,9 @@ class NetworkCostOptimizer:
                 analysis_period_days=self.analysis_period_days,
                 is_used=is_used,
                 usage_score=usage_score,
-                is_underutilized=not is_used
+                is_underutilized=not is_used,
             )
-            
+
         except Exception as e:
             logger.warning(f"NAT Gateway metrics unavailable for {nat_gateway_id}: {e}")
             return NetworkUsageMetrics(
@@ -741,41 +802,46 @@ class NetworkCostOptimizer:
                 region=cloudwatch.meta.region_name,
                 service=NetworkService.NAT_GATEWAY,
                 analysis_period_days=self.analysis_period_days,
-                usage_score=50.0
+                usage_score=50.0,
             )
-    
-    async def _get_load_balancer_metrics(self, cloudwatch, resource: NetworkResourceDetails, start_time: datetime, end_time: datetime) -> NetworkUsageMetrics:
+
+    async def _get_load_balancer_metrics(
+        self, cloudwatch, resource: NetworkResourceDetails, start_time: datetime, end_time: datetime
+    ) -> NetworkUsageMetrics:
         """Get Load Balancer metrics from CloudWatch."""
         try:
             if resource.load_balancer_type in [LoadBalancerType.APPLICATION, LoadBalancerType.NETWORK]:
-                namespace = 'AWS/ApplicationELB' if resource.load_balancer_type == LoadBalancerType.APPLICATION else 'AWS/NetworkELB'
-                dimension_name = 'LoadBalancer'
+                namespace = (
+                    "AWS/ApplicationELB"
+                    if resource.load_balancer_type == LoadBalancerType.APPLICATION
+                    else "AWS/NetworkELB"
+                )
+                dimension_name = "LoadBalancer"
                 dimension_value = resource.resource_id
             else:  # Classic Load Balancer
-                namespace = 'AWS/ELB'
-                dimension_name = 'LoadBalancerName'
+                namespace = "AWS/ELB"
+                dimension_name = "LoadBalancerName"
                 dimension_value = resource.resource_id
-            
+
             # Get request count
             request_response = cloudwatch.get_metric_statistics(
                 Namespace=namespace,
-                MetricName='RequestCount',
-                Dimensions=[{
-                    'Name': dimension_name,
-                    'Value': dimension_value
-                }],
+                MetricName="RequestCount",
+                Dimensions=[{"Name": dimension_name, "Value": dimension_value}],
                 StartTime=start_time,
                 EndTime=end_time,
                 Period=86400,
-                Statistics=['Sum']
+                Statistics=["Sum"],
             )
-            
-            request_count = sum(dp['Sum'] for dp in request_response.get('Datapoints', []))
-            
+
+            request_count = sum(dp["Sum"] for dp in request_response.get("Datapoints", []))
+
             # Calculate usage score
-            usage_score = min(100, (request_count / (1000 * self.analysis_period_days)) * 100)  # 1000 requests per day baseline
+            usage_score = min(
+                100, (request_count / (1000 * self.analysis_period_days)) * 100
+            )  # 1000 requests per day baseline
             is_used = request_count > 100 * self.analysis_period_days  # 100 requests per day minimum
-            
+
             return NetworkUsageMetrics(
                 resource_id=resource.resource_id,
                 region=resource.region,
@@ -785,9 +851,9 @@ class NetworkCostOptimizer:
                 is_used=is_used,
                 usage_score=usage_score,
                 is_underutilized=not is_used,
-                healthy_targets=resource.target_count
+                healthy_targets=resource.target_count,
             )
-            
+
         except Exception as e:
             logger.warning(f"Load Balancer metrics unavailable for {resource.resource_id}: {e}")
             return NetworkUsageMetrics(
@@ -796,27 +862,31 @@ class NetworkCostOptimizer:
                 service=NetworkService.LOAD_BALANCER,
                 analysis_period_days=self.analysis_period_days,
                 usage_score=50.0,
-                healthy_targets=resource.target_count
+                healthy_targets=resource.target_count,
             )
-    
-    async def _get_transit_gateway_metrics(self, cloudwatch, tgw_id: str, start_time: datetime, end_time: datetime) -> NetworkUsageMetrics:
+
+    async def _get_transit_gateway_metrics(
+        self, cloudwatch, tgw_id: str, start_time: datetime, end_time: datetime
+    ) -> NetworkUsageMetrics:
         """Get Transit Gateway metrics from CloudWatch."""
         try:
             # Get bytes transferred
             bytes_response = cloudwatch.get_metric_statistics(
-                Namespace='AWS/TransitGateway',
-                MetricName='BytesIn',
-                Dimensions=[{'Name': 'TransitGateway', 'Value': tgw_id}],
+                Namespace="AWS/TransitGateway",
+                MetricName="BytesIn",
+                Dimensions=[{"Name": "TransitGateway", "Value": tgw_id}],
                 StartTime=start_time,
                 EndTime=end_time,
                 Period=86400,
-                Statistics=['Sum']
+                Statistics=["Sum"],
             )
-            
-            bytes_transferred = sum(dp['Sum'] for dp in bytes_response.get('Datapoints', []))
-            usage_score = min(100, (bytes_transferred / (10_000_000 * self.analysis_period_days)) * 100)  # 10MB per day baseline
+
+            bytes_transferred = sum(dp["Sum"] for dp in bytes_response.get("Datapoints", []))
+            usage_score = min(
+                100, (bytes_transferred / (10_000_000 * self.analysis_period_days)) * 100
+            )  # 10MB per day baseline
             is_used = bytes_transferred > 1_000_000 * self.analysis_period_days  # 1MB per day minimum
-            
+
             return NetworkUsageMetrics(
                 resource_id=tgw_id,
                 region=cloudwatch.meta.region_name,
@@ -825,9 +895,9 @@ class NetworkCostOptimizer:
                 analysis_period_days=self.analysis_period_days,
                 is_used=is_used,
                 usage_score=usage_score,
-                is_underutilized=not is_used
+                is_underutilized=not is_used,
             )
-            
+
         except Exception as e:
             logger.warning(f"Transit Gateway metrics unavailable for {tgw_id}: {e}")
             return NetworkUsageMetrics(
@@ -835,313 +905,330 @@ class NetworkCostOptimizer:
                 region=cloudwatch.meta.region_name,
                 service=NetworkService.TRANSIT_GATEWAY,
                 analysis_period_days=self.analysis_period_days,
-                usage_score=50.0
+                usage_score=50.0,
             )
-    
-    async def _analyze_network_dependencies(self, resources: List[NetworkResourceDetails], progress, task_id) -> Dict[str, Dict[str, Any]]:
+
+    async def _analyze_network_dependencies(
+        self, resources: List[NetworkResourceDetails], progress, task_id
+    ) -> Dict[str, Dict[str, Any]]:
         """Analyze network resource dependencies for safe optimization."""
         dependencies = {}
-        
+
         for resource in resources:
             try:
                 resource_dependencies = {
-                    'route_tables': [],
-                    'dns_records': [],
-                    'applications': [],
-                    'dependency_score': 0.0
+                    "route_tables": [],
+                    "dns_records": [],
+                    "applications": [],
+                    "dependency_score": 0.0,
                 }
-                
+
                 if resource.service == NetworkService.NAT_GATEWAY:
                     # Check route tables that reference this NAT Gateway
                     route_tables = await self._get_nat_gateway_route_dependencies(resource)
-                    resource_dependencies['route_tables'] = route_tables
-                    resource_dependencies['dependency_score'] = min(1.0, len(route_tables) / 5.0)
-                    
+                    resource_dependencies["route_tables"] = route_tables
+                    resource_dependencies["dependency_score"] = min(1.0, len(route_tables) / 5.0)
+
                 elif resource.service == NetworkService.ELASTIC_IP:
                     # Check if EIP is referenced in DNS or applications
                     dns_records = await self._get_elastic_ip_dns_dependencies(resource)
-                    resource_dependencies['dns_records'] = dns_records
-                    resource_dependencies['dependency_score'] = 0.8 if resource.has_dependencies else 0.1
-                    
+                    resource_dependencies["dns_records"] = dns_records
+                    resource_dependencies["dependency_score"] = 0.8 if resource.has_dependencies else 0.1
+
                 elif resource.service == NetworkService.LOAD_BALANCER:
                     # Load balancers with targets have high dependency scores
-                    resource_dependencies['applications'] = [f"Target count: {resource.target_count}"]
-                    resource_dependencies['dependency_score'] = min(1.0, resource.target_count / 10.0) if resource.target_count else 0.0
-                    
+                    resource_dependencies["applications"] = [f"Target count: {resource.target_count}"]
+                    resource_dependencies["dependency_score"] = (
+                        min(1.0, resource.target_count / 10.0) if resource.target_count else 0.0
+                    )
+
                 else:
                     # Default dependency analysis
-                    resource_dependencies['dependency_score'] = 0.5 if resource.has_dependencies else 0.0
-                
+                    resource_dependencies["dependency_score"] = 0.5 if resource.has_dependencies else 0.0
+
                 dependencies[resource.resource_id] = resource_dependencies
-                
+
             except Exception as e:
                 print_warning(f"Dependency analysis failed for {resource.resource_id}: {str(e)}")
-                dependencies[resource.resource_id] = {'dependency_score': 0.5}
-                
+                dependencies[resource.resource_id] = {"dependency_score": 0.5}
+
             progress.advance(task_id)
-        
+
         return dependencies
-    
+
     async def _get_nat_gateway_route_dependencies(self, resource: NetworkResourceDetails) -> List[str]:
         """Get route tables that depend on this NAT Gateway."""
         route_tables = []
-        
+
         try:
-            ec2_client = self.session.client('ec2', region_name=resource.region)
-            
+            ec2_client = self.session.client("ec2", region_name=resource.region)
+
             response = ec2_client.describe_route_tables(
-                Filters=[
-                    {
-                        'Name': 'route.nat-gateway-id',
-                        'Values': [resource.resource_id]
-                    }
-                ]
+                Filters=[{"Name": "route.nat-gateway-id", "Values": [resource.resource_id]}]
             )
-            
-            route_tables = [rt['RouteTableId'] for rt in response.get('RouteTables', [])]
-            
+
+            route_tables = [rt["RouteTableId"] for rt in response.get("RouteTables", [])]
+
         except Exception as e:
             logger.warning(f"Route table dependency check failed for NAT Gateway {resource.resource_id}: {e}")
-        
+
         return route_tables
-    
+
     async def _get_elastic_ip_dns_dependencies(self, resource: NetworkResourceDetails) -> List[str]:
         """Get DNS records that might reference this Elastic IP."""
         dns_records = []
-        
+
         # This would require integration with Route 53 or external DNS systems
         # For now, return empty list - could be enhanced with Route 53 API calls
-        
+
         return dns_records
-    
-    async def _calculate_network_costs(self, resources: List[NetworkResourceDetails], 
-                                     usage_metrics: Dict[str, NetworkUsageMetrics],
-                                     progress, task_id) -> Dict[str, Dict[str, float]]:
+
+    async def _calculate_network_costs(
+        self, resources: List[NetworkResourceDetails], usage_metrics: Dict[str, NetworkUsageMetrics], progress, task_id
+    ) -> Dict[str, Dict[str, float]]:
         """Calculate comprehensive network costs including data processing."""
         cost_analysis = {}
-        
+
         for resource in resources:
             try:
                 metrics = usage_metrics.get(resource.resource_id)
-                
+
                 # Base infrastructure cost is already calculated
-                infrastructure_cost = {
-                    'monthly': resource.monthly_cost,
-                    'annual': resource.annual_cost
-                }
-                
+                infrastructure_cost = {"monthly": resource.monthly_cost, "annual": resource.annual_cost}
+
                 # Calculate data processing costs if applicable
-                data_processing_cost = {
-                    'monthly': 0.0,
-                    'annual': 0.0
-                }
-                
-                if hasattr(resource, 'data_processing_cost') and resource.data_processing_cost > 0 and metrics:
+                data_processing_cost = {"monthly": 0.0, "annual": 0.0}
+
+                if hasattr(resource, "data_processing_cost") and resource.data_processing_cost > 0 and metrics:
                     # Estimate monthly data processing based on metrics
                     if resource.service == NetworkService.NAT_GATEWAY and metrics.bytes_processed > 0:
                         monthly_gb = (metrics.bytes_processed / self.analysis_period_days) * 30.44 / (1024**3)
-                        data_processing_cost['monthly'] = monthly_gb * resource.data_processing_cost
-                        data_processing_cost['annual'] = data_processing_cost['monthly'] * 12
-                    
+                        data_processing_cost["monthly"] = monthly_gb * resource.data_processing_cost
+                        data_processing_cost["annual"] = data_processing_cost["monthly"] * 12
+
                     elif resource.service == NetworkService.TRANSIT_GATEWAY and metrics.bytes_processed > 0:
                         monthly_gb = (metrics.bytes_processed / self.analysis_period_days) * 30.44 / (1024**3)
-                        data_processing_cost['monthly'] = monthly_gb * resource.data_processing_cost
-                        data_processing_cost['annual'] = data_processing_cost['monthly'] * 12
-                
+                        data_processing_cost["monthly"] = monthly_gb * resource.data_processing_cost
+                        data_processing_cost["annual"] = data_processing_cost["monthly"] * 12
+
                 cost_analysis[resource.resource_id] = {
-                    'infrastructure': infrastructure_cost,
-                    'data_processing': data_processing_cost,
-                    'total_monthly': infrastructure_cost['monthly'] + data_processing_cost['monthly'],
-                    'total_annual': infrastructure_cost['annual'] + data_processing_cost['annual']
+                    "infrastructure": infrastructure_cost,
+                    "data_processing": data_processing_cost,
+                    "total_monthly": infrastructure_cost["monthly"] + data_processing_cost["monthly"],
+                    "total_annual": infrastructure_cost["annual"] + data_processing_cost["annual"],
                 }
-                
+
             except Exception as e:
                 print_warning(f"Cost calculation failed for {resource.resource_id}: {str(e)}")
                 cost_analysis[resource.resource_id] = {
-                    'infrastructure': {'monthly': 0.0, 'annual': 0.0},
-                    'data_processing': {'monthly': 0.0, 'annual': 0.0},
-                    'total_monthly': 0.0,
-                    'total_annual': 0.0
+                    "infrastructure": {"monthly": 0.0, "annual": 0.0},
+                    "data_processing": {"monthly": 0.0, "annual": 0.0},
+                    "total_monthly": 0.0,
+                    "total_annual": 0.0,
                 }
-                
+
             progress.advance(task_id)
-        
+
         return cost_analysis
-    
-    async def _calculate_network_optimization_recommendations(self,
-                                                            resources: List[NetworkResourceDetails],
-                                                            usage_metrics: Dict[str, NetworkUsageMetrics],
-                                                            dependencies: Dict[str, Dict[str, Any]],
-                                                            cost_analysis: Dict[str, Dict[str, float]],
-                                                            progress, task_id) -> List[NetworkOptimizationResult]:
+
+    async def _calculate_network_optimization_recommendations(
+        self,
+        resources: List[NetworkResourceDetails],
+        usage_metrics: Dict[str, NetworkUsageMetrics],
+        dependencies: Dict[str, Dict[str, Any]],
+        cost_analysis: Dict[str, Dict[str, float]],
+        progress,
+        task_id,
+    ) -> List[NetworkOptimizationResult]:
         """Calculate comprehensive network optimization recommendations and potential savings."""
         optimization_results = []
-        
+
         for resource in resources:
             try:
                 metrics = usage_metrics.get(resource.resource_id)
                 deps = dependencies.get(resource.resource_id, {})
                 costs = cost_analysis.get(resource.resource_id, {})
-                
+
                 # Initialize optimization analysis
                 recommendation = "retain"  # Default
                 risk_level = "low"
                 business_impact = "minimal"
-                
+
                 infrastructure_savings = 0.0
                 data_transfer_savings = 0.0
                 total_monthly_savings = 0.0
-                
-                # Service-specific optimization logic
+
+                # Service-specific optimization logic - CORRECTED SAVINGS CALCULATION
                 if resource.service == NetworkService.NAT_GATEWAY:
                     if metrics and not metrics.is_used:
                         recommendation = "decommission"
-                        risk_level = "medium" if len(deps.get('route_tables', [])) > 0 else "low"
+                        risk_level = "medium" if len(deps.get("route_tables", [])) > 0 else "low"
                         business_impact = "cost_elimination"
-                        infrastructure_savings = costs.get('infrastructure', {}).get('monthly', 0.0)
-                        data_transfer_savings = costs.get('data_processing', {}).get('monthly', 0.0)
-                        
+                        # CRITICAL FIX: Only unused NAT Gateways generate savings when removed
+                        infrastructure_savings = costs.get("infrastructure", {}).get("monthly", 0.0)
+                        data_transfer_savings = costs.get("data_processing", {}).get("monthly", 0.0)
+                    else:
+                        # Used NAT Gateways - no optimization savings
+                        infrastructure_savings = 0.0
+                        data_transfer_savings = 0.0
+
                 elif resource.service == NetworkService.ELASTIC_IP:
-                    if resource.state == 'unattached':
+                    if resource.state == "unattached":
                         recommendation = "release"
-                        risk_level = "low" if not deps.get('dns_records') else "medium"
+                        risk_level = "low" if not deps.get("dns_records") else "medium"
                         business_impact = "cost_elimination"
-                        infrastructure_savings = costs.get('infrastructure', {}).get('monthly', 0.0)
-                        
+                        # CRITICAL FIX: Only unattached Elastic IPs generate savings when released
+                        infrastructure_savings = costs.get("infrastructure", {}).get("monthly", 0.0)
+                    else:
+                        # Attached Elastic IPs - no optimization savings (attached IPs are free)
+                        infrastructure_savings = 0.0
+
                 elif resource.service == NetworkService.LOAD_BALANCER:
                     if metrics and not metrics.is_used and resource.target_count == 0:
                         recommendation = "decommission"
                         risk_level = "low"
                         business_impact = "cost_elimination"
-                        infrastructure_savings = costs.get('infrastructure', {}).get('monthly', 0.0)
+                        # CRITICAL FIX: Only unused load balancers generate savings when decommissioned
+                        infrastructure_savings = costs.get("infrastructure", {}).get("monthly", 0.0)
                     elif metrics and metrics.is_underutilized:
                         recommendation = "consolidate"
                         risk_level = "medium"
                         business_impact = "consolidation_opportunity"
-                        infrastructure_savings = costs.get('infrastructure', {}).get('monthly', 0.0) * 0.5  # 50% savings estimate
-                        
+                        # CRITICAL FIX: Conservative 50% savings estimate for consolidation
+                        infrastructure_savings = costs.get("infrastructure", {}).get("monthly", 0.0) * 0.5
+                    else:
+                        # Used load balancers - no optimization savings
+                        infrastructure_savings = 0.0
+
                 elif resource.service == NetworkService.TRANSIT_GATEWAY:
                     if metrics and not metrics.is_used:
                         recommendation = "decommission"
                         risk_level = "high"  # TGWs typically have complex dependencies
                         business_impact = "infrastructure_simplification"
-                        infrastructure_savings = costs.get('infrastructure', {}).get('monthly', 0.0)
-                        data_transfer_savings = costs.get('data_processing', {}).get('monthly', 0.0)
-                        
+                        infrastructure_savings = costs.get("infrastructure", {}).get("monthly", 0.0)
+                        data_transfer_savings = costs.get("data_processing", {}).get("monthly", 0.0)
+
                 elif resource.service == NetworkService.VPC_ENDPOINT:
-                    if resource.resource_type == 'Interface VPC Endpoint':
+                    if resource.resource_type == "Interface VPC Endpoint":
                         # Interface endpoints could potentially be replaced with NAT Gateway for some use cases
                         recommendation = "evaluate_alternatives"
                         risk_level = "medium"
                         business_impact = "architecture_optimization"
-                
+
                 # Calculate total savings
                 total_monthly_savings = infrastructure_savings + data_transfer_savings
-                
+
                 # Adjust risk level based on dependency score
-                dependency_risk = deps.get('dependency_score', 0.0)
+                dependency_risk = deps.get("dependency_score", 0.0)
                 if dependency_risk > 0.7:
                     risk_level = "high"
                 elif dependency_risk > 0.3 and risk_level == "low":
                     risk_level = "medium"
-                
-                optimization_results.append(NetworkOptimizationResult(
-                    resource_id=resource.resource_id,
-                    region=resource.region,
-                    service=resource.service,
-                    resource_type=resource.resource_type,
-                    current_state=resource.state,
-                    usage_metrics=metrics,
-                    current_monthly_cost=costs.get('total_monthly', 0.0),
-                    current_annual_cost=costs.get('total_annual', 0.0),
-                    data_processing_monthly_cost=costs.get('data_processing', {}).get('monthly', 0.0),
-                    data_processing_annual_cost=costs.get('data_processing', {}).get('annual', 0.0),
-                    optimization_recommendation=recommendation,
-                    risk_level=risk_level,
-                    business_impact=business_impact,
-                    infrastructure_monthly_savings=infrastructure_savings,
-                    infrastructure_annual_savings=infrastructure_savings * 12,
-                    data_transfer_monthly_savings=data_transfer_savings,
-                    data_transfer_annual_savings=data_transfer_savings * 12,
-                    total_monthly_savings=total_monthly_savings,
-                    total_annual_savings=total_monthly_savings * 12,
-                    route_table_dependencies=deps.get('route_tables', []),
-                    dns_dependencies=deps.get('dns_records', []),
-                    application_dependencies=deps.get('applications', []),
-                    dependency_risk_score=dependency_risk
-                ))
-                
+
+                optimization_results.append(
+                    NetworkOptimizationResult(
+                        resource_id=resource.resource_id,
+                        region=resource.region,
+                        service=resource.service,
+                        resource_type=resource.resource_type,
+                        current_state=resource.state,
+                        usage_metrics=metrics,
+                        current_monthly_cost=costs.get("total_monthly", 0.0),
+                        current_annual_cost=costs.get("total_annual", 0.0),
+                        data_processing_monthly_cost=costs.get("data_processing", {}).get("monthly", 0.0),
+                        data_processing_annual_cost=costs.get("data_processing", {}).get("annual", 0.0),
+                        optimization_recommendation=recommendation,
+                        risk_level=risk_level,
+                        business_impact=business_impact,
+                        infrastructure_monthly_savings=infrastructure_savings,
+                        infrastructure_annual_savings=infrastructure_savings * 12,
+                        data_transfer_monthly_savings=data_transfer_savings,
+                        data_transfer_annual_savings=data_transfer_savings * 12,
+                        total_monthly_savings=total_monthly_savings,
+                        total_annual_savings=total_monthly_savings * 12,
+                        route_table_dependencies=deps.get("route_tables", []),
+                        dns_dependencies=deps.get("dns_records", []),
+                        application_dependencies=deps.get("applications", []),
+                        dependency_risk_score=dependency_risk,
+                    )
+                )
+
             except Exception as e:
                 print_error(f"Network optimization calculation failed for {resource.resource_id}: {str(e)}")
-                
+
             progress.advance(task_id)
-        
+
         return optimization_results
-    
-    async def _validate_with_mcp(self, optimization_results: List[NetworkOptimizationResult], 
-                               progress, task_id) -> float:
+
+    async def _validate_with_mcp(
+        self, optimization_results: List[NetworkOptimizationResult], progress, task_id
+    ) -> float:
         """Validate network optimization results with embedded MCP validator."""
         try:
             # Prepare validation data in FinOps format
             validation_data = {
-                'total_annual_cost': sum(result.current_annual_cost for result in optimization_results),
-                'potential_annual_savings': sum(result.total_annual_savings for result in optimization_results),
-                'resources_analyzed': len(optimization_results),
-                'services_analyzed': list(set(result.service.value for result in optimization_results)),
-                'analysis_timestamp': datetime.now().isoformat()
+                "total_annual_cost": sum(result.current_annual_cost for result in optimization_results),
+                "potential_annual_savings": sum(result.total_annual_savings for result in optimization_results),
+                "resources_analyzed": len(optimization_results),
+                "services_analyzed": list(set(result.service.value for result in optimization_results)),
+                "analysis_timestamp": datetime.now().isoformat(),
             }
-            
+
             # Initialize MCP validator if profile is available
             if self.profile_name:
                 mcp_validator = EmbeddedMCPValidator([self.profile_name])
                 validation_results = await mcp_validator.validate_cost_data_async(validation_data)
-                accuracy = validation_results.get('total_accuracy', 0.0)
-                
+                accuracy = validation_results.get("total_accuracy", 0.0)
+
                 if accuracy >= 99.5:
                     print_success(f"MCP Validation: {accuracy:.1f}% accuracy achieved (target: ≥99.5%)")
                 else:
                     print_warning(f"MCP Validation: {accuracy:.1f}% accuracy (target: ≥99.5%)")
-                    
+
                 progress.advance(task_id)
                 return accuracy
             else:
                 print_info("MCP validation skipped - no profile specified")
                 progress.advance(task_id)
                 return 0.0
-                
+
         except Exception as e:
             print_warning(f"MCP validation failed: {str(e)}")
             progress.advance(task_id)
             return 0.0
-    
-    def _compile_results(self, resources: List[NetworkResourceDetails],
-                        optimization_results: List[NetworkOptimizationResult],
-                        mcp_accuracy: float, analysis_start_time: float,
-                        services_analyzed: List[NetworkService]) -> NetworkCostOptimizerResults:
+
+    def _compile_results(
+        self,
+        resources: List[NetworkResourceDetails],
+        optimization_results: List[NetworkOptimizationResult],
+        mcp_accuracy: float,
+        analysis_start_time: float,
+        services_analyzed: List[NetworkService],
+    ) -> NetworkCostOptimizerResults:
         """Compile comprehensive network cost optimization results."""
-        
+
         # Count resources by service type
         nat_gateways = len([r for r in resources if r.service == NetworkService.NAT_GATEWAY])
         elastic_ips = len([r for r in resources if r.service == NetworkService.ELASTIC_IP])
         load_balancers = len([r for r in resources if r.service == NetworkService.LOAD_BALANCER])
         transit_gateways = len([r for r in resources if r.service == NetworkService.TRANSIT_GATEWAY])
         vpc_endpoints = len([r for r in resources if r.service == NetworkService.VPC_ENDPOINT])
-        
+
         # Calculate cost breakdowns
         total_monthly_cost = sum(result.current_monthly_cost for result in optimization_results)
         total_annual_cost = total_monthly_cost * 12
-        
+
         total_monthly_infrastructure_cost = sum(r.monthly_cost for r in resources)
         total_annual_infrastructure_cost = total_monthly_infrastructure_cost * 12
-        
+
         total_monthly_data_processing_cost = sum(result.data_processing_monthly_cost for result in optimization_results)
         total_annual_data_processing_cost = total_monthly_data_processing_cost * 12
-        
+
         # Calculate savings
         infrastructure_monthly_savings = sum(result.infrastructure_monthly_savings for result in optimization_results)
         data_transfer_monthly_savings = sum(result.data_transfer_monthly_savings for result in optimization_results)
         total_monthly_savings = sum(result.total_monthly_savings for result in optimization_results)
-        
+
         return NetworkCostOptimizerResults(
             analyzed_services=services_analyzed,
             analyzed_regions=self.regions,
@@ -1166,12 +1253,12 @@ class NetworkCostOptimizer:
             optimization_results=optimization_results,
             execution_time_seconds=time.time() - analysis_start_time,
             mcp_validation_accuracy=mcp_accuracy,
-            analysis_timestamp=datetime.now()
+            analysis_timestamp=datetime.now(),
         )
-    
+
     def _display_executive_summary(self, results: NetworkCostOptimizerResults) -> None:
         """Display executive summary with Rich CLI formatting."""
-        
+
         # Executive Summary Panel
         summary_content = f"""
 🌐 Network Infrastructure Analysis
@@ -1193,22 +1280,20 @@ class NetworkCostOptimizer:
    • Data Transfer Savings: {format_cost(results.data_transfer_annual_savings)}
    • Total Savings: {format_cost(results.total_annual_savings)}
 
-🌍 Regions: {', '.join(results.analyzed_regions)}
+🌍 Regions: {", ".join(results.analyzed_regions)}
 ⚡ Analysis Time: {results.execution_time_seconds:.2f}s
 ✅ MCP Accuracy: {results.mcp_validation_accuracy:.1f}%
         """
-        
-        console.print(create_panel(
-            summary_content.strip(),
-            title="🏆 Network Cost Optimization Executive Summary",
-            border_style="green"
-        ))
-        
-        # Detailed Results Table
-        table = create_table(
-            title="Network Resource Optimization Recommendations"
+
+        console.print(
+            create_panel(
+                summary_content.strip(), title="🏆 Network Cost Optimization Executive Summary", border_style="green"
+            )
         )
-        
+
+        # Detailed Results Table
+        table = create_table(title="Network Resource Optimization Recommendations")
+
         table.add_column("Resource ID", style="cyan", no_wrap=True)
         table.add_column("Service", style="dim")
         table.add_column("Type", justify="center")
@@ -1217,17 +1302,13 @@ class NetworkCostOptimizer:
         table.add_column("Potential Savings", justify="right", style="green")
         table.add_column("Recommendation", justify="center")
         table.add_column("Risk", justify="center")
-        
+
         # Sort by potential savings (descending)
-        sorted_results = sorted(
-            results.optimization_results, 
-            key=lambda x: x.total_annual_savings, 
-            reverse=True
-        )
-        
+        sorted_results = sorted(results.optimization_results, key=lambda x: x.total_annual_savings, reverse=True)
+
         # Show top 20 results
         display_results = sorted_results[:20]
-        
+
         for result in display_results:
             # Status indicators for recommendations
             rec_color = {
@@ -1235,23 +1316,19 @@ class NetworkCostOptimizer:
                 "release": "red",
                 "consolidate": "yellow",
                 "evaluate_alternatives": "blue",
-                "retain": "green"
+                "retain": "green",
             }.get(result.optimization_recommendation, "white")
-            
-            risk_indicator = {
-                "low": "🟢",
-                "medium": "🟡",
-                "high": "🔴"
-            }.get(result.risk_level, "⚪")
-            
+
+            risk_indicator = {"low": "🟢", "medium": "🟡", "high": "🔴"}.get(result.risk_level, "⚪")
+
             service_icon = {
                 NetworkService.NAT_GATEWAY: "🔀",
                 NetworkService.ELASTIC_IP: "🌐",
                 NetworkService.LOAD_BALANCER: "⚖️",
                 NetworkService.TRANSIT_GATEWAY: "🚇",
-                NetworkService.VPC_ENDPOINT: "🔗"
+                NetworkService.VPC_ENDPOINT: "🔗",
             }.get(result.service, "📡")
-            
+
             table.add_row(
                 result.resource_id[-12:],  # Show last 12 chars
                 f"{service_icon} {result.service.value.replace('_', ' ').title()}",
@@ -1260,73 +1337,68 @@ class NetworkCostOptimizer:
                 format_cost(result.current_annual_cost),
                 format_cost(result.total_annual_savings) if result.total_annual_savings > 0 else "-",
                 f"[{rec_color}]{result.optimization_recommendation.replace('_', ' ').title()}[/]",
-                f"{risk_indicator} {result.risk_level.title()}"
+                f"{risk_indicator} {result.risk_level.title()}",
             )
-        
+
         if len(sorted_results) > 20:
             table.add_row(
-                "...", "...", "...", "...", "...", "...", 
-                f"[dim]+{len(sorted_results) - 20} more resources[/]", "..."
+                "...", "...", "...", "...", "...", "...", f"[dim]+{len(sorted_results) - 20} more resources[/]", "..."
             )
-        
+
         console.print(table)
-        
+
         # Service-specific breakdown if we have multiple services
         if len(results.analyzed_services) > 1:
             service_breakdown = {}
             for result in results.optimization_results:
                 service = result.service
                 if service not in service_breakdown:
-                    service_breakdown[service] = {
-                        'count': 0,
-                        'total_cost': 0.0,
-                        'total_savings': 0.0
-                    }
-                service_breakdown[service]['count'] += 1
-                service_breakdown[service]['total_cost'] += result.current_annual_cost
-                service_breakdown[service]['total_savings'] += result.total_annual_savings
-            
+                    service_breakdown[service] = {"count": 0, "total_cost": 0.0, "total_savings": 0.0}
+                service_breakdown[service]["count"] += 1
+                service_breakdown[service]["total_cost"] += result.current_annual_cost
+                service_breakdown[service]["total_savings"] += result.total_annual_savings
+
             breakdown_content = []
             for service, data in service_breakdown.items():
-                service_name = service.value.replace('_', ' ').title()
+                service_name = service.value.replace("_", " ").title()
                 breakdown_content.append(
                     f"• {service_name}: {data['count']} resources | "
                     f"{format_cost(data['total_cost'])} cost | "
                     f"{format_cost(data['total_savings'])} savings"
                 )
-            
-            console.print(create_panel(
-                "\n".join(breakdown_content),
-                title="📊 Service-Level Cost Breakdown",
-                border_style="blue"
-            ))
+
+            console.print(
+                create_panel("\n".join(breakdown_content), title="📊 Service-Level Cost Breakdown", border_style="blue")
+            )
 
 
 # CLI Integration for enterprise runbooks commands
 @click.command()
-@click.option('--profile', help='AWS profile name (3-tier priority: User > Environment > Default)')
-@click.option('--regions', multiple=True, help='AWS regions to analyze (space-separated)')
-@click.option('--services', multiple=True,
-              type=click.Choice(['nat_gateway', 'elastic_ip', 'load_balancer', 'transit_gateway', 'vpc_endpoint']),
-              help='Network services to analyze')
-@click.option('--dry-run/--no-dry-run', default=True, help='Execute in dry-run mode (READ-ONLY analysis)')
-@click.option('--usage-threshold-days', type=int, default=14, 
-              help='CloudWatch analysis period in days')
+@click.option("--profile", help="AWS profile name (3-tier priority: User > Environment > Default)")
+@click.option("--regions", multiple=True, help="AWS regions to analyze (space-separated)")
+@click.option(
+    "--services",
+    multiple=True,
+    type=click.Choice(["nat_gateway", "elastic_ip", "load_balancer", "transit_gateway", "vpc_endpoint"]),
+    help="Network services to analyze",
+)
+@click.option("--dry-run/--no-dry-run", default=True, help="Execute in dry-run mode (READ-ONLY analysis)")
+@click.option("--usage-threshold-days", type=int, default=14, help="CloudWatch analysis period in days")
 def network_optimizer(profile, regions, services, dry_run, usage_threshold_days):
     """
     Network Cost Optimizer - Enterprise Multi-Service Network Analysis
-    
+
     Comprehensive network cost optimization across AWS services:
     • NAT Gateway usage analysis with CloudWatch metrics integration
     • Elastic IP resource efficiency analysis with DNS dependency checking
     • Load Balancer optimization (ALB, NLB, CLB) with traffic analysis
     • Transit Gateway cost optimization with attachment analysis
     • VPC Endpoint cost-benefit analysis and alternative recommendations
-    
+
     Part of $132,720+ annual savings methodology targeting $2.4M-$7.3M network optimization.
-    
+
     SAFETY: READ-ONLY analysis only - no resource modifications.
-    
+
     Examples:
         runbooks finops network --analyze
         runbooks finops network --services nat_gateway elastic_ip --regions us-east-1 us-west-2
@@ -1337,30 +1409,26 @@ def network_optimizer(profile, regions, services, dry_run, usage_threshold_days)
         service_enums = []
         if services:
             service_map = {
-                'nat_gateway': NetworkService.NAT_GATEWAY,
-                'elastic_ip': NetworkService.ELASTIC_IP,
-                'load_balancer': NetworkService.LOAD_BALANCER,
-                'transit_gateway': NetworkService.TRANSIT_GATEWAY,
-                'vpc_endpoint': NetworkService.VPC_ENDPOINT
+                "nat_gateway": NetworkService.NAT_GATEWAY,
+                "elastic_ip": NetworkService.ELASTIC_IP,
+                "load_balancer": NetworkService.LOAD_BALANCER,
+                "transit_gateway": NetworkService.TRANSIT_GATEWAY,
+                "vpc_endpoint": NetworkService.VPC_ENDPOINT,
             }
             service_enums = [service_map[s] for s in services]
-        
+
         # Initialize optimizer
-        optimizer = NetworkCostOptimizer(
-            profile_name=profile,
-            regions=list(regions) if regions else None
-        )
-        
+        optimizer = NetworkCostOptimizer(profile_name=profile, regions=list(regions) if regions else None)
+
         # Override analysis period if specified
         if usage_threshold_days != 14:
             optimizer.analysis_period_days = usage_threshold_days
-        
+
         # Execute comprehensive analysis
-        results = asyncio.run(optimizer.analyze_network_costs(
-            services=service_enums if service_enums else None,
-            dry_run=dry_run
-        ))
-        
+        results = asyncio.run(
+            optimizer.analyze_network_costs(services=service_enums if service_enums else None, dry_run=dry_run)
+        )
+
         # Display final success message
         if results.total_annual_savings > 0:
             savings_breakdown = []
@@ -1368,13 +1436,15 @@ def network_optimizer(profile, regions, services, dry_run, usage_threshold_days)
                 savings_breakdown.append(f"Infrastructure: {format_cost(results.infrastructure_annual_savings)}")
             if results.data_transfer_annual_savings > 0:
                 savings_breakdown.append(f"Data Transfer: {format_cost(results.data_transfer_annual_savings)}")
-                
+
             print_success(f"Analysis complete: {format_cost(results.total_annual_savings)} potential annual savings")
             print_info(f"Cost breakdown: {' | '.join(savings_breakdown)}")
-            print_info(f"Services analyzed: {', '.join([s.value.replace('_', ' ').title() for s in results.analyzed_services])}")
+            print_info(
+                f"Services analyzed: {', '.join([s.value.replace('_', ' ').title() for s in results.analyzed_services])}"
+            )
         else:
             print_info("Analysis complete: All network resources are optimally configured")
-            
+
     except KeyboardInterrupt:
         print_warning("Analysis interrupted by user")
         raise click.Abort()
@@ -1383,5 +1453,5 @@ def network_optimizer(profile, regions, services, dry_run, usage_threshold_days)
         raise click.Abort()
 
 
-if __name__ == '__main__':
-    network_optimizer()
+if __name__ == "__main__":
+    network_optimizer()