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

runbooks/cloudops/cost_optimizer.py

@@ -29,20 +29,35 @@ from datetime import datetime, timedelta
 from dataclasses import dataclass
 
 from runbooks.common.rich_utils import (
-    console, print_header, print_success, print_error, print_warning, print_info,
-    create_table, create_progress_bar, format_cost, create_panel
+    console,
+    print_header,
+    print_success,
+    print_error,
+    print_warning,
+    print_info,
+    create_table,
+    create_progress_bar,
+    format_cost,
+    create_panel,
 )
 from runbooks.common.aws_pricing import get_service_monthly_cost, calculate_annual_cost, calculate_regional_cost
 from runbooks.common.env_utils import get_required_env_float
 from .base import CloudOpsBase
 from .models import (
-    CostOptimizationResult, BusinessScenario, ExecutionMode, RiskLevel,
-    ResourceImpact, BusinessMetrics, ComplianceMetrics
+    CostOptimizationResult,
+    BusinessScenario,
+    ExecutionMode,
+    RiskLevel,
+    ResourceImpact,
+    BusinessMetrics,
+    ComplianceMetrics,
 )
 
+
 @dataclass
 class CostAnalysisData:
     """Internal data structure for cost analysis."""
+
     resource_id: str
     resource_type: str
     region: str
@@ -52,24 +67,25 @@ class CostAnalysisData:
     projected_savings: float
     risk_assessment: str
 
+
 class CostOptimizer(CloudOpsBase):
     """
     Cost optimization scenarios for emergency response and routine optimization.
-    
+
     Business Use Cases:
     1. Emergency cost spike investigation and remediation
-    2. Routine cost optimization campaigns  
+    2. Routine cost optimization campaigns
     3. Reserved instance planning and optimization
     4. Idle resource identification and cleanup
     5. Executive cost reporting and analysis
     """
-    
+
     def __init__(
         self,
         profile: str = "default",
         dry_run: bool = True,
         execution_mode: ExecutionMode = ExecutionMode.DRY_RUN,
-        region: str = "us-east-1"
+        region: str = "us-east-1",
     ):
         """
         Initialize Cost Optimizer with enterprise patterns.
@@ -86,6 +102,7 @@ class CostOptimizer(CloudOpsBase):
         self.region = region
 
         from runbooks import __version__
+
         print_header("CloudOps Cost Optimizer", __version__)
         print_info(f"Execution mode: {execution_mode.value}")
         print_info(f"Profile: {profile}")
@@ -103,11 +120,12 @@ class CostOptimizer(CloudOpsBase):
         Returns:
             Execution time in seconds
         """
-        if hasattr(self, 'operation_start_time'):
+        if hasattr(self, "operation_start_time"):
             return time.time() - self.operation_start_time
         else:
             # Fallback if start time not tracked
             import time
+
             return time.time() - time.time()  # Returns ~0.0
 
     def _suggest_smaller_instance_type(self, instance_type: str) -> Optional[str]:
@@ -123,326 +141,329 @@ class CostOptimizer(CloudOpsBase):
         # Simple rightsizing mapping - can be enhanced with CloudWatch metrics
         rightsizing_map = {
             # T3 family
-            't3.large': 't3.medium',
-            't3.xlarge': 't3.large',
-            't3.2xlarge': 't3.xlarge',
-
+            "t3.large": "t3.medium",
+            "t3.xlarge": "t3.large",
+            "t3.2xlarge": "t3.xlarge",
             # M5 family
-            'm5.large': 'm5.medium',
-            'm5.xlarge': 'm5.large',
-            'm5.2xlarge': 'm5.xlarge',
-            'm5.4xlarge': 'm5.2xlarge',
-
+            "m5.large": "m5.medium",
+            "m5.xlarge": "m5.large",
+            "m5.2xlarge": "m5.xlarge",
+            "m5.4xlarge": "m5.2xlarge",
             # C5 family
-            'c5.large': 'c5.medium',
-            'c5.xlarge': 'c5.large',
-            'c5.2xlarge': 'c5.xlarge',
-            'c5.4xlarge': 'c5.2xlarge',
-
+            "c5.large": "c5.medium",
+            "c5.xlarge": "c5.large",
+            "c5.2xlarge": "c5.xlarge",
+            "c5.4xlarge": "c5.2xlarge",
             # R5 family
-            'r5.large': 'r5.medium',
-            'r5.xlarge': 'r5.large',
-            'r5.2xlarge': 'r5.xlarge',
+            "r5.large": "r5.medium",
+            "r5.xlarge": "r5.large",
+            "r5.2xlarge": "r5.xlarge",
         }
 
         return rightsizing_map.get(instance_type)
 
     async def discover_infrastructure(
-        self,
-        regions: Optional[List[str]] = None,
-        services: Optional[List[str]] = None
+        self, regions: Optional[List[str]] = None, services: Optional[List[str]] = None
     ) -> Any:
         """
         Comprehensive infrastructure discovery for cost optimization analysis.
-        
+
         Args:
             regions: AWS regions to analyze (default: common regions)
             services: AWS services to discover (default: cost-relevant services)
-            
+
         Returns:
             Discovery result with resource counts and cost estimates
         """
         if regions is None:
-            regions = ['us-east-1', 'us-west-2', 'eu-west-1', 'ap-southeast-1']
-        
+            regions = ["us-east-1", "us-west-2", "eu-west-1", "ap-southeast-1"]
+
         if services is None:
-            services = ['ec2', 'ebs', 's3', 'rds', 'vpc', 'lambda']
-        
-        discovery_data = {
-            'resources_analyzed': 0,
-            'service_summaries': [],
-            'estimated_total_cost': 0.0
-        }
-        
+            services = ["ec2", "ebs", "s3", "rds", "vpc", "lambda"]
+
+        discovery_data = {"resources_analyzed": 0, "service_summaries": [], "estimated_total_cost": 0.0}
+
         print_info("🔍 Starting infrastructure discovery...")
-        
+
         with create_progress_bar() as progress:
-            discovery_task = progress.add_task(
-                "[cyan]Discovering AWS resources...", 
-                total=len(services)
-            )
-            
+            discovery_task = progress.add_task("[cyan]Discovering AWS resources...", total=len(services))
+
             for service in services:
-                service_summary = await self._discover_service_resources(
-                    service, regions
-                )
-                discovery_data['service_summaries'].append(service_summary)
-                discovery_data['resources_analyzed'] += service_summary['resource_count']
-                discovery_data['estimated_total_cost'] += service_summary['estimated_cost']
-                
+                service_summary = await self._discover_service_resources(service, regions)
+                discovery_data["service_summaries"].append(service_summary)
+                discovery_data["resources_analyzed"] += service_summary["resource_count"]
+                discovery_data["estimated_total_cost"] += service_summary["estimated_cost"]
+
                 progress.advance(discovery_task)
-        
+
         print_success(f"Discovery completed: {discovery_data['resources_analyzed']} resources found")
-        return type('DiscoveryResult', (), discovery_data)
-    
-    async def _discover_service_resources(
-        self, 
-        service: str, 
-        regions: List[str]
-    ) -> Dict[str, Any]:
+        return type("DiscoveryResult", (), discovery_data)
+
+    async def _discover_service_resources(self, service: str, regions: List[str]) -> Dict[str, Any]:
         """Discover resources for a specific AWS service."""
         try:
-            if service == 'ec2':
+            if service == "ec2":
                 return await self._discover_ec2_resources(regions)
-            elif service == 'ebs':
+            elif service == "ebs":
                 return await self._discover_ebs_resources(regions)
-            elif service == 's3':
+            elif service == "s3":
                 return await self._discover_s3_resources()
-            elif service == 'rds':
+            elif service == "rds":
                 return await self._discover_rds_resources(regions)
-            elif service == 'vpc':
+            elif service == "vpc":
                 return await self._discover_vpc_resources(regions)
             else:
                 # Generic discovery for other services
                 return {
-                    'service': service,
-                    'resource_count': 0,
-                    'estimated_cost': 0.0,
-                    'optimization_opportunities': []
+                    "service": service,
+                    "resource_count": 0,
+                    "estimated_cost": 0.0,
+                    "optimization_opportunities": [],
                 }
         except Exception as e:
             print_warning(f"Service {service} discovery failed: {str(e)}")
-            return {
-                'service': service,
-                'resource_count': 0,
-                'estimated_cost': 0.0,
-                'error': str(e)
-            }
-    
+            return {"service": service, "resource_count": 0, "estimated_cost": 0.0, "error": str(e)}
+
     async def _discover_ec2_resources(self, regions: List[str]) -> Dict[str, Any]:
         """Discover EC2 instances across regions."""
         total_instances = 0
         estimated_cost = 0.0
-        
+
         for region in regions:
             try:
-                ec2 = self.session.client('ec2', region_name=region)
+                ec2 = self.session.client("ec2", region_name=region)
                 response = ec2.describe_instances()
-                
-                for reservation in response['Reservations']:
-                    for instance in reservation['Instances']:
-                        if instance['State']['Name'] in ['running', 'stopped']:
+
+                for reservation in response["Reservations"]:
+                    for instance in reservation["Instances"]:
+                        if instance["State"]["Name"] in ["running", "stopped"]:
                             total_instances += 1
                             # Dynamic cost estimation
-                            instance_type = instance.get('InstanceType', 't3.micro')
+                            instance_type = instance.get("InstanceType", "t3.micro")
                             estimated_cost += self._estimate_ec2_cost(instance_type, region)
-                            
+
             except Exception as e:
                 print_warning(f"EC2 discovery failed in {region}: {str(e)}")
-        
+
         return {
-            'service': 'EC2',
-            'resource_count': total_instances,
-            'estimated_cost': estimated_cost,
-            'optimization_opportunities': ['rightsizing', 'idle_detection', 'reserved_instances']
+            "service": "EC2",
+            "resource_count": total_instances,
+            "estimated_cost": estimated_cost,
+            "optimization_opportunities": ["rightsizing", "idle_detection", "reserved_instances"],
         }
-    
+
     async def _discover_ebs_resources(self, regions: List[str]) -> Dict[str, Any]:
         """Discover EBS volumes across regions."""
         total_volumes = 0
         estimated_cost = 0.0
-        
+
         for region in regions:
             try:
-                ec2 = self.session.client('ec2', region_name=region)
+                ec2 = self.session.client("ec2", region_name=region)
                 response = ec2.describe_volumes()
-                
-                for volume in response['Volumes']:
+
+                for volume in response["Volumes"]:
                     total_volumes += 1
-                    volume_size = volume.get('Size', 0)
-                    volume_type = volume.get('VolumeType', 'gp2')
+                    volume_size = volume.get("Size", 0)
+                    volume_type = volume.get("VolumeType", "gp2")
                     estimated_cost += self._estimate_ebs_cost(volume_size, volume_type, region)
-                    
+
             except Exception as e:
                 print_warning(f"EBS discovery failed in {region}: {str(e)}")
-        
+
         return {
-            'service': 'EBS',
-            'resource_count': total_volumes,
-            'estimated_cost': estimated_cost,
-            'optimization_opportunities': ['unattached_volumes', 'snapshot_cleanup', 'storage_type_optimization']
+            "service": "EBS",
+            "resource_count": total_volumes,
+            "estimated_cost": estimated_cost,
+            "optimization_opportunities": ["unattached_volumes", "snapshot_cleanup", "storage_type_optimization"],
         }
-    
+
     async def _discover_s3_resources(self) -> Dict[str, Any]:
         """Discover S3 buckets and estimate costs."""
         try:
-            s3 = self.session.client('s3')
+            s3 = self.session.client("s3")
             response = s3.list_buckets()
-            
-            bucket_count = len(response['Buckets'])
+
+            bucket_count = len(response["Buckets"])
             # S3 cost estimation - using standard storage baseline per bucket
             estimated_cost = bucket_count * get_service_monthly_cost("s3_standard", "us-east-1")
-            
+
             return {
-                'service': 'S3',
-                'resource_count': bucket_count,
-                'estimated_cost': estimated_cost,
-                'optimization_opportunities': ['lifecycle_policies', 'storage_class_optimization', 'request_optimization']
+                "service": "S3",
+                "resource_count": bucket_count,
+                "estimated_cost": estimated_cost,
+                "optimization_opportunities": [
+                    "lifecycle_policies",
+                    "storage_class_optimization",
+                    "request_optimization",
+                ],
             }
-            
+
         except Exception as e:
             print_warning(f"S3 discovery failed: {str(e)}")
-            return {'service': 'S3', 'resource_count': 0, 'estimated_cost': 0.0}
-    
+            return {"service": "S3", "resource_count": 0, "estimated_cost": 0.0}
+
     async def _discover_rds_resources(self, regions: List[str]) -> Dict[str, Any]:
         """Discover RDS instances across regions."""
         total_instances = 0
         estimated_cost = 0.0
-        
+
         for region in regions:
             try:
-                rds = self.session.client('rds', region_name=region)
+                rds = self.session.client("rds", region_name=region)
                 response = rds.describe_db_instances()
-                
-                for instance in response['DBInstances']:
+
+                for instance in response["DBInstances"]:
                     total_instances += 1
-                    instance_class = instance.get('DBInstanceClass', 'db.t3.micro')
+                    instance_class = instance.get("DBInstanceClass", "db.t3.micro")
                     estimated_cost += self._estimate_rds_cost(instance_class, region)
-                    
+
             except Exception as e:
                 print_warning(f"RDS discovery failed in {region}: {str(e)}")
-        
+
         return {
-            'service': 'RDS',
-            'resource_count': total_instances,
-            'estimated_cost': estimated_cost,
-            'optimization_opportunities': ['instance_rightsizing', 'reserved_instances', 'storage_optimization']
+            "service": "RDS",
+            "resource_count": total_instances,
+            "estimated_cost": estimated_cost,
+            "optimization_opportunities": ["instance_rightsizing", "reserved_instances", "storage_optimization"],
         }
-    
+
     async def _discover_vpc_resources(self, regions: List[str]) -> Dict[str, Any]:
         """Discover VPC resources (NAT Gateways, EIPs, etc.)."""
         total_resources = 0
         estimated_cost = 0.0
-        
+
         for region in regions:
             try:
-                ec2 = self.session.client('ec2', region_name=region)
-                
+                ec2 = self.session.client("ec2", region_name=region)
+
                 # NAT Gateways
                 nat_response = ec2.describe_nat_gateways()
-                nat_count = len(nat_response['NatGateways'])
+                nat_count = len(nat_response["NatGateways"])
                 total_resources += nat_count
                 estimated_cost += nat_count * get_service_monthly_cost("nat_gateway", region)
-                
+
                 # Elastic IPs
                 eip_response = ec2.describe_addresses()
-                eip_count = len(eip_response['Addresses'])
+                eip_count = len(eip_response["Addresses"])
                 total_resources += eip_count
                 estimated_cost += eip_count * get_service_monthly_cost("elastic_ip", region)
-                
+
             except Exception as e:
                 print_warning(f"VPC discovery failed in {region}: {str(e)}")
-        
+
         return {
-            'service': 'VPC',
-            'resource_count': total_resources,
-            'estimated_cost': estimated_cost,
-            'optimization_opportunities': ['unused_nat_gateways', 'unused_eips', 'load_balancer_optimization']
+            "service": "VPC",
+            "resource_count": total_resources,
+            "estimated_cost": estimated_cost,
+            "optimization_opportunities": ["unused_nat_gateways", "unused_eips", "load_balancer_optimization"],
         }
-    
+
     def _estimate_ec2_cost(self, instance_type: str, region: str = "us-east-1") -> float:
         """EC2 cost estimation using dynamic pricing with fallback."""
         try:
             # Map instance types to AWS pricing service keys
             # For simplicity, using a base cost multiplier approach
             base_cost = get_service_monthly_cost("ec2_instance", region)
-            
+
             # Instance type multipliers based on AWS pricing patterns
             type_multipliers = {
-                't3.nano': 0.1, 't3.micro': 0.2, 't3.small': 0.4,
-                't3.medium': 0.8, 't3.large': 1.6, 't3.xlarge': 3.2,
-                'm5.large': 1.8, 'm5.xlarge': 3.6, 'm5.2xlarge': 7.2,
-                'c5.large': 1.6, 'c5.xlarge': 3.2, 'c5.2xlarge': 6.4
+                "t3.nano": 0.1,
+                "t3.micro": 0.2,
+                "t3.small": 0.4,
+                "t3.medium": 0.8,
+                "t3.large": 1.6,
+                "t3.xlarge": 3.2,
+                "m5.large": 1.8,
+                "m5.xlarge": 3.6,
+                "m5.2xlarge": 7.2,
+                "c5.large": 1.6,
+                "c5.xlarge": 3.2,
+                "c5.2xlarge": 6.4,
             }
-            
+
             multiplier = type_multipliers.get(instance_type, 1.0)
             return base_cost * multiplier
-            
+
         except Exception:
             # Fallback to regional cost calculation if service key not available
             base_costs = {
-                't3.nano': 3.8, 't3.micro': 7.6, 't3.small': 15.2,
-                't3.medium': 30.4, 't3.large': 60.8, 't3.xlarge': 121.6,
-                'm5.large': 70.1, 'm5.xlarge': 140.2, 'm5.2xlarge': 280.3,
-                'c5.large': 62.1, 'c5.xlarge': 124.2, 'c5.2xlarge': 248.4
+                "t3.nano": 3.8,
+                "t3.micro": 7.6,
+                "t3.small": 15.2,
+                "t3.medium": 30.4,
+                "t3.large": 60.8,
+                "t3.xlarge": 121.6,
+                "m5.large": 70.1,
+                "m5.xlarge": 140.2,
+                "m5.2xlarge": 280.3,
+                "c5.large": 62.1,
+                "c5.xlarge": 124.2,
+                "c5.2xlarge": 248.4,
             }
             base_cost = base_costs.get(instance_type, 50.0)
             return calculate_regional_cost(base_cost, region)
-    
+
     def _estimate_ebs_cost(self, size_gb: int, volume_type: str, region: str = "us-east-1") -> float:
         """EBS cost estimation using dynamic pricing."""
         try:
             # Map volume types to service keys in our pricing engine
             volume_service_map = {
-                'gp2': 'ebs_gp2',
-                'gp3': 'ebs_gp3', 
-                'io1': 'ebs_io1',
-                'io2': 'ebs_io2',
-                'sc1': 'ebs_sc1',
-                'st1': 'ebs_st1'
+                "gp2": "ebs_gp2",
+                "gp3": "ebs_gp3",
+                "io1": "ebs_io1",
+                "io2": "ebs_io2",
+                "sc1": "ebs_sc1",
+                "st1": "ebs_st1",
             }
-            
-            service_key = volume_service_map.get(volume_type, 'ebs_gp2')  # Default to gp2
+
+            service_key = volume_service_map.get(volume_type, "ebs_gp2")  # Default to gp2
             cost_per_gb = get_service_monthly_cost(service_key, region)
             return size_gb * cost_per_gb
-            
+
         except Exception:
             # Fallback to regional cost calculation
-            cost_per_gb_base = {
-                'gp2': 0.10, 'gp3': 0.08, 'io1': 0.125, 'io2': 0.125, 'sc1': 0.025, 'st1': 0.045
-            }
+            cost_per_gb_base = {"gp2": 0.10, "gp3": 0.08, "io1": 0.125, "io2": 0.125, "sc1": 0.025, "st1": 0.045}
             base_cost_per_gb = cost_per_gb_base.get(volume_type, 0.10)
             regional_cost_per_gb = calculate_regional_cost(base_cost_per_gb, region)
             return size_gb * regional_cost_per_gb
-    
+
     def _estimate_rds_cost(self, instance_class: str, region: str = "us-east-1") -> float:
         """RDS cost estimation using dynamic pricing with fallback."""
         try:
             # Use RDS snapshot pricing as a baseline, then apply instance multipliers
             base_cost = get_service_monthly_cost("rds_snapshot", region)
-            
+
             # Instance class multipliers based on AWS RDS pricing patterns
             class_multipliers = {
-                'db.t3.micro': 1.0, 'db.t3.small': 2.0, 'db.t3.medium': 4.0,
-                'db.m5.large': 9.6, 'db.m5.xlarge': 19.2, 'db.m5.2xlarge': 38.4
+                "db.t3.micro": 1.0,
+                "db.t3.small": 2.0,
+                "db.t3.medium": 4.0,
+                "db.m5.large": 9.6,
+                "db.m5.xlarge": 19.2,
+                "db.m5.2xlarge": 38.4,
             }
-            
+
             multiplier = class_multipliers.get(instance_class, 6.8)  # Reasonable default multiplier
             return base_cost * multiplier
-            
+
         except Exception:
             # Fallback to regional cost calculation
             base_costs = {
-                'db.t3.micro': 14.6, 'db.t3.small': 29.2, 'db.t3.medium': 58.4,
-                'db.m5.large': 140.2, 'db.m5.xlarge': 280.3, 'db.m5.2xlarge': 560.6
+                "db.t3.micro": 14.6,
+                "db.t3.small": 29.2,
+                "db.t3.medium": 58.4,
+                "db.m5.large": 140.2,
+                "db.m5.xlarge": 280.3,
+                "db.m5.2xlarge": 560.6,
             }
             base_cost = base_costs.get(instance_class, 100.0)
             return calculate_regional_cost(base_cost, region)
-    
+
     async def analyze_ec2_rightsizing(self) -> Dict[str, Any]:
         """Analyze EC2 instances for rightsizing opportunities."""
         print_info("🔍 Analyzing EC2 rightsizing opportunities...")
-        
+
         # Real AWS integration for rightsizing analysis
         from runbooks.common.aws_pricing import get_aws_pricing_engine, get_ec2_monthly_cost
 
@@ -450,18 +471,18 @@ class CostOptimizer(CloudOpsBase):
             pricing_engine = get_aws_pricing_engine(profile=self.profile)
 
             # Get actual EC2 instances from AWS API
-            ec2_client = self.session.client('ec2')
+            ec2_client = self.session.client("ec2")
             response = ec2_client.describe_instances()
 
             instances_analyzed = 0
             oversized_instances = 0
             potential_monthly_savings = 0.0
 
-            for reservation in response['Reservations']:
-                for instance in reservation['Instances']:
-                    if instance['State']['Name'] in ['running', 'stopped']:
+            for reservation in response["Reservations"]:
+                for instance in reservation["Instances"]:
+                    if instance["State"]["Name"] in ["running", "stopped"]:
                         instances_analyzed += 1
-                        instance_type = instance['InstanceType']
+                        instance_type = instance["InstanceType"]
 
                         # Calculate potential savings from rightsizing
                         current_cost = get_ec2_monthly_cost(instance_type, self.region, self.profile)
@@ -472,27 +493,27 @@ class CostOptimizer(CloudOpsBase):
                             smaller_cost = get_ec2_monthly_cost(smaller_instance, self.region, self.profile)
                             if smaller_cost < current_cost:
                                 oversized_instances += 1
-                                potential_monthly_savings += (current_cost - smaller_cost)
+                                potential_monthly_savings += current_cost - smaller_cost
 
             return {
-                'instances_analyzed': instances_analyzed,
-                'oversized_instances': oversized_instances,
-                'potential_savings': round(potential_monthly_savings, 2),
-                'resources_analyzed': instances_analyzed,
-                'resource_impacts': []
+                "instances_analyzed": instances_analyzed,
+                "oversized_instances": oversized_instances,
+                "potential_savings": round(potential_monthly_savings, 2),
+                "resources_analyzed": instances_analyzed,
+                "resource_impacts": [],
             }
 
         except Exception as e:
             print_warning(f"Could not get real EC2 data: {e}")
             # Return minimal fallback
             return {
-                'instances_analyzed': 0,
-                'oversized_instances': 0,
-                'potential_savings': 0.0,
-                'resources_analyzed': 0,
-                'resource_impacts': []
+                "instances_analyzed": 0,
+                "oversized_instances": 0,
+                "potential_savings": 0.0,
+                "resources_analyzed": 0,
+                "resource_impacts": [],
             }
-    
+
     async def analyze_ebs_optimization(self) -> Dict[str, Any]:
         """Analyze EBS volumes for optimization opportunities."""
         print_info("🔍 Analyzing EBS optimization opportunities...")
@@ -502,47 +523,47 @@ class CostOptimizer(CloudOpsBase):
 
         try:
             # Get actual EBS volumes from AWS API
-            ec2_client = self.session.client('ec2')
+            ec2_client = self.session.client("ec2")
             response = ec2_client.describe_volumes()
 
-            volumes_analyzed = len(response['Volumes'])
+            volumes_analyzed = len(response["Volumes"])
             unattached_volumes = 0
             oversized_volumes = 0
             potential_monthly_savings = 0.0
 
-            for volume in response['Volumes']:
+            for volume in response["Volumes"]:
                 # Count unattached volumes
-                if volume['State'] == 'available':
+                if volume["State"] == "available":
                     unattached_volumes += 1
-                    volume_size = volume['Size']
-                    volume_type = volume.get('VolumeType', 'gp3')
+                    volume_size = volume["Size"]
+                    volume_type = volume.get("VolumeType", "gp3")
                     cost_per_gb = get_ebs_gb_monthly_cost(volume_type, self.region, self.profile)
-                    potential_monthly_savings += (volume_size * cost_per_gb)
+                    potential_monthly_savings += volume_size * cost_per_gb
 
                 # Identify potentially oversized volumes (basic heuristic)
-                elif volume['State'] == 'in-use' and volume['Size'] > 100:
+                elif volume["State"] == "in-use" and volume["Size"] > 100:
                     oversized_volumes += 1
 
             return {
-                'volumes_analyzed': volumes_analyzed,
-                'unattached_volumes': unattached_volumes,
-                'oversized_volumes': oversized_volumes,
-                'potential_savings': round(potential_monthly_savings, 2),
-                'resources_analyzed': volumes_analyzed,
-                'resource_impacts': []
+                "volumes_analyzed": volumes_analyzed,
+                "unattached_volumes": unattached_volumes,
+                "oversized_volumes": oversized_volumes,
+                "potential_savings": round(potential_monthly_savings, 2),
+                "resources_analyzed": volumes_analyzed,
+                "resource_impacts": [],
             }
 
         except Exception as e:
             print_warning(f"Could not get real EBS data: {e}")
             return {
-                'volumes_analyzed': 0,
-                'unattached_volumes': 0,
-                'oversized_volumes': 0,
-                'potential_savings': 0.0,
-                'resources_analyzed': 0,
-                'resource_impacts': []
+                "volumes_analyzed": 0,
+                "unattached_volumes": 0,
+                "oversized_volumes": 0,
+                "potential_savings": 0.0,
+                "resources_analyzed": 0,
+                "resource_impacts": [],
             }
-    
+
     async def analyze_unused_resources(self) -> Dict[str, Any]:
         """Analyze and identify unused AWS resources."""
         print_info("🔍 Analyzing unused resources...")
@@ -551,55 +572,60 @@ class CostOptimizer(CloudOpsBase):
         from runbooks.common.aws_pricing import get_eip_monthly_cost, get_ebs_gb_monthly_cost
 
         try:
-            ec2_client = self.session.client('ec2')
+            ec2_client = self.session.client("ec2")
 
             # Analyze unused Elastic IPs
             eips_response = ec2_client.describe_addresses()
-            eip_unused = len([eip for eip in eips_response['Addresses'] if 'AssociationId' not in eip])
+            eip_unused = len([eip for eip in eips_response["Addresses"] if "AssociationId" not in eip])
 
             # Analyze unattached volumes (already calculated in EBS optimization)
             volumes_response = ec2_client.describe_volumes()
-            volumes_unattached = len([vol for vol in volumes_response['Volumes'] if vol['State'] == 'available'])
+            volumes_unattached = len([vol for vol in volumes_response["Volumes"] if vol["State"] == "available"])
 
             # Analyze old snapshots (older than 30 days)
             from datetime import datetime, timedelta
+
             cutoff_date = datetime.now() - timedelta(days=30)
-            snapshots_response = ec2_client.describe_snapshots(OwnerIds=['self'])
-            snapshots_old = len([
-                snap for snap in snapshots_response['Snapshots']
-                if datetime.fromisoformat(snap['StartTime'].replace('Z', '+00:00')).replace(tzinfo=None) < cutoff_date
-            ])
+            snapshots_response = ec2_client.describe_snapshots(OwnerIds=["self"])
+            snapshots_old = len(
+                [
+                    snap
+                    for snap in snapshots_response["Snapshots"]
+                    if datetime.fromisoformat(snap["StartTime"].replace("Z", "+00:00")).replace(tzinfo=None)
+                    < cutoff_date
+                ]
+            )
 
             # Calculate potential savings
             eip_monthly_cost = get_eip_monthly_cost(self.region, self.profile)
             potential_eip_savings = eip_unused * eip_monthly_cost
 
             # Estimate EBS snapshot costs (minimal but accumulated)
-            ebs_cost_per_gb = get_ebs_gb_monthly_cost('gp3', self.region, self.profile)
+            ebs_cost_per_gb = get_ebs_gb_monthly_cost("gp3", self.region, self.profile)
             estimated_snapshot_savings = snapshots_old * 5.0 * ebs_cost_per_gb  # Assume 5GB average per snapshot
 
             total_potential_savings = potential_eip_savings + estimated_snapshot_savings
 
             return {
-                'eip_unused': eip_unused,
-                'volumes_unattached': volumes_unattached,
-                'snapshots_old': snapshots_old,
-                'potential_savings': round(total_potential_savings, 2),
-                'resources_analyzed': eip_unused + volumes_unattached + snapshots_old,
-                'resource_impacts': []
+                "eip_unused": eip_unused,
+                "volumes_unattached": volumes_unattached,
+                "snapshots_old": snapshots_old,
+                "potential_savings": round(total_potential_savings, 2),
+                "resources_analyzed": eip_unused + volumes_unattached + snapshots_old,
+                "resource_impacts": [],
             }
 
         except Exception as e:
             print_warning(f"Could not get real unused resources data: {e}")
             return {
-                'eip_unused': 0,
-                'volumes_unattached': 0,
-                'snapshots_old': 0,
-                'potential_savings': 0.0,
-                'resources_analyzed': 0,
-                'resource_impacts': []
+                "eip_unused": 0,
+                "volumes_unattached": 0,
+                "snapshots_old": 0,
+                "potential_savings": 0.0,
+                "resources_analyzed": 0,
+                "resource_impacts": [],
             }
-    
+
     async def analyze_s3_optimization(self) -> Dict[str, Any]:
         """Analyze S3 buckets for storage class optimization using real AWS data."""
         print_info("🔍 Analyzing S3 optimization opportunities...")
@@ -611,11 +637,11 @@ class CostOptimizer(CloudOpsBase):
         resource_impacts = []
 
         try:
-            s3_client = self.session.client('s3')
+            s3_client = self.session.client("s3")
 
             # Get all S3 buckets
             response = s3_client.list_buckets()
-            all_buckets = response.get('Buckets', [])
+            all_buckets = response.get("Buckets", [])
             buckets_analyzed = len(all_buckets)
 
             print_info(f"Found {buckets_analyzed} S3 buckets for analysis")
@@ -625,12 +651,12 @@ class CostOptimizer(CloudOpsBase):
                 task = progress.add_task("[cyan]Analyzing S3 buckets...", total=len(all_buckets))
 
                 for bucket in all_buckets:
-                    bucket_name = bucket['Name']
+                    bucket_name = bucket["Name"]
 
                     try:
                         # Check bucket region to create regional client
                         bucket_region = await self._get_bucket_region(s3_client, bucket_name)
-                        regional_s3 = self.session.client('s3', region_name=bucket_region)
+                        regional_s3 = self.session.client("s3", region_name=bucket_region)
 
                         # Analyze lifecycle configuration
                         lifecycle_needed = await self._analyze_bucket_lifecycle(regional_s3, bucket_name)
@@ -639,9 +665,9 @@ class CostOptimizer(CloudOpsBase):
 
                         # Analyze storage class optimization
                         storage_optimization = await self._analyze_bucket_storage_classes(regional_s3, bucket_name)
-                        if storage_optimization['has_optimization_opportunity']:
+                        if storage_optimization["has_optimization_opportunity"]:
                             storage_class_optimization += 1
-                            potential_savings += storage_optimization['estimated_monthly_savings']
+                            potential_savings += storage_optimization["estimated_monthly_savings"]
 
                             # Create resource impact for this bucket
                             resource_impacts.append(
@@ -650,12 +676,12 @@ class CostOptimizer(CloudOpsBase):
                                     resource_id=bucket_name,
                                     region=bucket_region,
                                     account_id=self.account_id,
-                                    estimated_monthly_cost=storage_optimization['current_cost'],
-                                    projected_savings=storage_optimization['estimated_monthly_savings'],
+                                    estimated_monthly_cost=storage_optimization["current_cost"],
+                                    projected_savings=storage_optimization["estimated_monthly_savings"],
                                     risk_level=RiskLevel.LOW,
                                     modification_required=True,
                                     resource_name=f"S3 Bucket {bucket_name}",
-                                    estimated_downtime=0.0
+                                    estimated_downtime=0.0,
                                 )
                             )
 
@@ -681,29 +707,29 @@ class CostOptimizer(CloudOpsBase):
             potential_savings = 0.0
 
         return {
-            'buckets_analyzed': buckets_analyzed,
-            'lifecycle_opportunities': lifecycle_opportunities,
-            'storage_class_optimization': storage_class_optimization,
-            'potential_savings': potential_savings,
-            'resources_analyzed': buckets_analyzed,
-            'resource_impacts': resource_impacts
+            "buckets_analyzed": buckets_analyzed,
+            "lifecycle_opportunities": lifecycle_opportunities,
+            "storage_class_optimization": storage_class_optimization,
+            "potential_savings": potential_savings,
+            "resources_analyzed": buckets_analyzed,
+            "resource_impacts": resource_impacts,
         }
 
     async def _get_bucket_region(self, s3_client, bucket_name: str) -> str:
         """Get the region for a specific S3 bucket."""
         try:
             response = s3_client.get_bucket_location(Bucket=bucket_name)
-            region = response.get('LocationConstraint')
+            region = response.get("LocationConstraint")
 
             # Handle special case for US East 1
             if region is None:
-                return 'us-east-1'
+                return "us-east-1"
 
             return region
 
         except Exception as e:
             print_warning(f"Could not determine region for bucket {bucket_name}: {str(e)}")
-            return 'us-east-1'  # Default fallback
+            return "us-east-1"  # Default fallback
 
     async def _analyze_bucket_lifecycle(self, s3_client, bucket_name: str) -> bool:
         """
@@ -718,7 +744,7 @@ class CostOptimizer(CloudOpsBase):
                 # If lifecycle exists, assume it's already optimized
                 return False
             except ClientError as e:
-                if e.response['Error']['Code'] == 'NoSuchLifecycleConfiguration':
+                if e.response["Error"]["Code"] == "NoSuchLifecycleConfiguration":
                     # No lifecycle policy exists - could benefit from one
                     pass
                 else:
@@ -727,16 +753,16 @@ class CostOptimizer(CloudOpsBase):
 
             # Check bucket size and object count to determine if lifecycle is beneficial
             try:
-                paginator = s3_client.get_paginator('list_objects_v2')
-                page_iterator = paginator.paginate(Bucket=bucket_name, PaginationConfig={'MaxItems': 100})
+                paginator = s3_client.get_paginator("list_objects_v2")
+                page_iterator = paginator.paginate(Bucket=bucket_name, PaginationConfig={"MaxItems": 100})
 
                 object_count = 0
                 total_size = 0
 
                 for page in page_iterator:
-                    if 'Contents' in page:
-                        object_count += len(page['Contents'])
-                        total_size += sum(obj.get('Size', 0) for obj in page['Contents'])
+                    if "Contents" in page:
+                        object_count += len(page["Contents"])
+                        total_size += sum(obj.get("Size", 0) for obj in page["Contents"])
 
                 # Recommend lifecycle if bucket has significant content
                 # and could benefit from automatic transitions
@@ -760,138 +786,131 @@ class CostOptimizer(CloudOpsBase):
         """
         try:
             # Get storage class analytics if available
-            paginator = s3_client.get_paginator('list_objects_v2')
-            page_iterator = paginator.paginate(Bucket=bucket_name, PaginationConfig={'MaxItems': 1000})
+            paginator = s3_client.get_paginator("list_objects_v2")
+            page_iterator = paginator.paginate(Bucket=bucket_name, PaginationConfig={"MaxItems": 1000})
 
             storage_analysis = {
-                'standard_objects': 0,
-                'standard_size': 0,
-                'infrequent_access_candidates': 0,
-                'archive_candidates': 0,
-                'current_cost': 0.0,
-                'optimized_cost': 0.0,
-                'has_optimization_opportunity': False,
-                'estimated_monthly_savings': 0.0
+                "standard_objects": 0,
+                "standard_size": 0,
+                "infrequent_access_candidates": 0,
+                "archive_candidates": 0,
+                "current_cost": 0.0,
+                "optimized_cost": 0.0,
+                "has_optimization_opportunity": False,
+                "estimated_monthly_savings": 0.0,
             }
 
             current_time = datetime.now()
 
             for page in page_iterator:
-                if 'Contents' not in page:
+                if "Contents" not in page:
                     continue
 
-                for obj in page['Contents']:
-                    size_gb = obj.get('Size', 0) / (1024 * 1024 * 1024)  # Convert to GB
-                    last_modified = obj.get('LastModified', current_time)
+                for obj in page["Contents"]:
+                    size_gb = obj.get("Size", 0) / (1024 * 1024 * 1024)  # Convert to GB
+                    last_modified = obj.get("LastModified", current_time)
 
                     # Calculate age of object
-                    if hasattr(last_modified, 'replace'):
+                    if hasattr(last_modified, "replace"):
                         age_days = (current_time - last_modified.replace(tzinfo=None)).days
                     else:
                         age_days = 0
 
-                    storage_class = obj.get('StorageClass', 'STANDARD')
+                    storage_class = obj.get("StorageClass", "STANDARD")
 
                     # Analyze optimization opportunities
-                    if storage_class == 'STANDARD':
-                        storage_analysis['standard_objects'] += 1
-                        storage_analysis['standard_size'] += size_gb
+                    if storage_class == "STANDARD":
+                        storage_analysis["standard_objects"] += 1
+                        storage_analysis["standard_size"] += size_gb
 
                         # Current cost (Standard storage ~$0.023/GB/month)
                         standard_cost = size_gb * 0.023
-                        storage_analysis['current_cost'] += standard_cost
+                        storage_analysis["current_cost"] += standard_cost
 
                         # Check if object could be moved to cheaper storage class
                         if age_days > 30 and size_gb > 0.1:  # Objects older than 30 days and >100MB
-                            storage_analysis['infrequent_access_candidates'] += 1
+                            storage_analysis["infrequent_access_candidates"] += 1
                             # IA storage ~$0.0125/GB/month
                             ia_cost = size_gb * 0.0125
-                            storage_analysis['optimized_cost'] += ia_cost
+                            storage_analysis["optimized_cost"] += ia_cost
                         elif age_days > 90 and size_gb > 0.05:  # Objects older than 90 days
-                            storage_analysis['archive_candidates'] += 1
+                            storage_analysis["archive_candidates"] += 1
                             # Glacier ~$0.004/GB/month
                             glacier_cost = size_gb * 0.004
-                            storage_analysis['optimized_cost'] += glacier_cost
+                            storage_analysis["optimized_cost"] += glacier_cost
                         else:
                             # No optimization for this object
-                            storage_analysis['optimized_cost'] += standard_cost
+                            storage_analysis["optimized_cost"] += standard_cost
 
             # Calculate potential savings
-            potential_savings = storage_analysis['current_cost'] - storage_analysis['optimized_cost']
+            potential_savings = storage_analysis["current_cost"] - storage_analysis["optimized_cost"]
 
             if potential_savings > 1.0:  # Minimum $1/month savings to be worth it
-                storage_analysis['has_optimization_opportunity'] = True
-                storage_analysis['estimated_monthly_savings'] = potential_savings
+                storage_analysis["has_optimization_opportunity"] = True
+                storage_analysis["estimated_monthly_savings"] = potential_savings
 
             return storage_analysis
 
         except Exception as e:
             print_warning(f"Could not analyze storage classes for {bucket_name}: {str(e)}")
-            return {
-                'has_optimization_opportunity': False,
-                'estimated_monthly_savings': 0.0,
-                'current_cost': 0.0
-            }
+            return {"has_optimization_opportunity": False, "estimated_monthly_savings": 0.0, "current_cost": 0.0}
 
     async def optimize_nat_gateways(
-        self, 
-        regions: Optional[List[str]] = None,
-        idle_threshold_days: int = 7,
-        cost_threshold: float = 0.0
+        self, regions: Optional[List[str]] = None, idle_threshold_days: int = 7, cost_threshold: float = 0.0
     ) -> CostOptimizationResult:
         """
         Business Scenario: Delete unused NAT Gateways
         Source: AWS_Delete_Unused_NAT_Gateways.ipynb
-        
+
         Typical Business Impact:
         - Cost savings: significant value range/month per unused NAT Gateway
         - Risk level: Low (network connectivity analysis performed)
         - Implementation time: 15-30 minutes
-        
+
         Args:
             regions: Target regions (default: all available)
             idle_threshold_days: Days to consider NAT Gateway idle
             cost_threshold: Minimum monthly cost to consider for optimization
-            
+
         Returns:
             CostOptimizationResult with detailed savings and impact analysis
         """
         operation_name = "NAT Gateway Cost Optimization"
         print_header(f"🔍 {operation_name}")
-        
+
         # Initialize result tracking
         unused_gateways = []
         total_current_cost = 0.0
         total_projected_savings = 0.0
-        
+
         # Get target regions
-        target_regions = regions or self._get_available_regions('ec2')[:5]  # Limit for performance
-        
+        target_regions = regions or self._get_available_regions("ec2")[:5]  # Limit for performance
+
         print_info(f"Analyzing NAT Gateways across {len(target_regions)} regions")
         print_info(f"Idle threshold: {idle_threshold_days} days")
-        
+
         # Progress tracking
         with create_progress_bar() as progress:
             task = progress.add_task("[cyan]Scanning NAT Gateways...", total=len(target_regions))
-            
+
             for region in target_regions:
                 try:
                     region_gateways = await self._analyze_nat_gateways_in_region(
                         region, idle_threshold_days, cost_threshold
                     )
                     unused_gateways.extend(region_gateways)
-                    
+
                     progress.update(task, advance=1)
-                    
+
                 except Exception as e:
                     print_warning(f"Could not analyze region {region}: {str(e)}")
                     continue
-        
+
         # Calculate total impact
         for gateway in unused_gateways:
             total_current_cost += gateway.estimated_monthly_cost or 0
             total_projected_savings += gateway.projected_savings or 0
-        
+
         # Create resource impacts
         resource_impacts = [
             self.create_resource_impact(
@@ -903,23 +922,23 @@ class CostOptimizer(CloudOpsBase):
                 risk_level=RiskLevel.LOW,  # NAT Gateway deletion is typically low risk
                 modification_required=True,
                 resource_name=f"NAT Gateway {gateway.resource_id}",
-                estimated_downtime=0.0  # NAT Gateway deletion has no downtime impact
+                estimated_downtime=0.0,  # NAT Gateway deletion has no downtime impact
             )
             for gateway in unused_gateways
         ]
-        
+
         # Business impact analysis
         business_metrics = self.create_business_metrics(
             total_savings=total_projected_savings,
             implementation_cost=0.0,  # No implementation cost for deletion
-            overall_risk=RiskLevel.LOW
+            overall_risk=RiskLevel.LOW,
         )
-        
+
         # Executive summary display
         if unused_gateways:
             print_success(f"💰 Found {len(unused_gateways)} unused NAT Gateways")
             print_success(f"💵 Potential monthly savings: {format_cost(total_projected_savings)}")
-            
+
             # Detailed table
             nat_table = create_table(
                 title="Unused NAT Gateway Analysis",
@@ -928,27 +947,27 @@ class CostOptimizer(CloudOpsBase):
                     {"name": "Region", "style": "green"},
                     {"name": "Monthly Cost", "style": "cost"},
                     {"name": "Last Activity", "style": "yellow"},
-                    {"name": "Risk Level", "style": "blue"}
-                ]
+                    {"name": "Risk Level", "style": "blue"},
+                ],
             )
-            
+
             for gateway in unused_gateways[:10]:  # Show top 10 for readability
                 nat_table.add_row(
                     gateway.resource_id,
                     gateway.region,
                     format_cost(gateway.estimated_monthly_cost or 0),
                     f"{idle_threshold_days}+ days ago",
-                    gateway.risk_level.value.title()
+                    gateway.risk_level.value.title(),
                 )
-            
+
             console.print(nat_table)
-            
+
             if not self.dry_run and self.execution_mode == ExecutionMode.EXECUTE:
                 print_warning("⚡ Executing NAT Gateway deletion...")
                 await self._execute_nat_gateway_deletion(unused_gateways)
         else:
             print_info("✅ No unused NAT Gateways found - infrastructure is optimized")
-        
+
         # Create comprehensive result
         result = CostOptimizationResult(
             scenario=BusinessScenario.COST_OPTIMIZATION,
@@ -964,70 +983,64 @@ class CostOptimizer(CloudOpsBase):
             recommendations=[
                 "Set up CloudWatch alarms for NAT Gateway utilization monitoring",
                 "Consider VPC Endpoints to reduce NAT Gateway dependencies",
-                "Review network architecture for optimization opportunities"
+                "Review network architecture for optimization opportunities",
             ],
             aws_profile_used=self.profile,
             regions_analyzed=target_regions,
             services_analyzed=["ec2", "cloudwatch"],
-            
             # Cost-specific metrics
             current_monthly_spend=total_current_cost,
             optimized_monthly_spend=total_current_cost - total_projected_savings,
             savings_percentage=(total_projected_savings / total_current_cost * 100) if total_current_cost > 0 else 0,
             idle_resources=resource_impacts,
             oversized_resources=[],
-            unattached_resources=[]
+            unattached_resources=[],
         )
-        
+
         self.display_execution_summary(result)
         return result
-    
+
     async def _analyze_nat_gateways_in_region(
-        self, 
-        region: str, 
-        idle_threshold_days: int,
-        cost_threshold: float
+        self, region: str, idle_threshold_days: int, cost_threshold: float
     ) -> List[ResourceImpact]:
         """
         Analyze NAT Gateways in a specific region for optimization opportunities.
-        
+
         Args:
             region: AWS region to analyze
             idle_threshold_days: Days to consider idle
             cost_threshold: Minimum cost threshold
-            
+
         Returns:
             List of unused NAT Gateway ResourceImpacts
         """
         unused_gateways = []
-        
+
         try:
-            ec2 = self.session.client('ec2', region_name=region)
-            cloudwatch = self.session.client('cloudwatch', region_name=region)
-            
+            ec2 = self.session.client("ec2", region_name=region)
+            cloudwatch = self.session.client("cloudwatch", region_name=region)
+
             # Get all NAT Gateways in region
             response = ec2.describe_nat_gateways()
-            
-            for nat_gateway in response.get('NatGateways', []):
-                gateway_id = nat_gateway['NatGatewayId']
-                state = nat_gateway['State']
-                
+
+            for nat_gateway in response.get("NatGateways", []):
+                gateway_id = nat_gateway["NatGatewayId"]
+                state = nat_gateway["State"]
+
                 # Only analyze available gateways
-                if state != 'available':
+                if state != "available":
                     continue
-                
+
                 # Check utilization over the threshold period
-                is_unused = await self._check_nat_gateway_utilization(
-                    cloudwatch, gateway_id, idle_threshold_days
-                )
-                
+                is_unused = await self._check_nat_gateway_utilization(cloudwatch, gateway_id, idle_threshold_days)
+
                 if is_unused:
                     # Estimate cost using dynamic pricing
                     estimated_cost = get_service_monthly_cost("nat_gateway", region)
-                    
+
                     # Add data processing costs if available
                     # (This would require more detailed Cost Explorer integration)
-                    
+
                     if estimated_cost >= cost_threshold:
                         unused_gateway = ResourceImpact(
                             resource_type="nat-gateway",
@@ -1039,78 +1052,71 @@ class CostOptimizer(CloudOpsBase):
                             risk_level=RiskLevel.LOW,
                             modification_required=True,
                             resource_name=f"NAT Gateway {gateway_id}",
-                            estimated_downtime=0.0
+                            estimated_downtime=0.0,
                         )
                         unused_gateways.append(unused_gateway)
-                        
+
         except ClientError as e:
             print_warning(f"Could not analyze NAT Gateways in {region}: {str(e)}")
-        
+
         return unused_gateways
-    
-    async def _check_nat_gateway_utilization(
-        self, 
-        cloudwatch_client, 
-        gateway_id: str, 
-        days: int
-    ) -> bool:
+
+    async def _check_nat_gateway_utilization(self, cloudwatch_client, gateway_id: str, days: int) -> bool:
         """
         Check if NAT Gateway has been idle based on CloudWatch metrics.
-        
+
         Args:
             cloudwatch_client: CloudWatch client for the region
             gateway_id: NAT Gateway ID
             days: Number of days to check
-            
+
         Returns:
             True if NAT Gateway appears unused, False otherwise
         """
         try:
             end_time = datetime.utcnow()
             start_time = end_time - timedelta(days=days)
-            
+
             # Check bytes transferred metric
             response = cloudwatch_client.get_metric_statistics(
-                Namespace='AWS/NatGateway',
-                MetricName='BytesInFromDestination',
-                Dimensions=[
-                    {'Name': 'NatGatewayId', 'Value': gateway_id}
-                ],
+                Namespace="AWS/NatGateway",
+                MetricName="BytesInFromDestination",
+                Dimensions=[{"Name": "NatGatewayId", "Value": gateway_id}],
                 StartTime=start_time,
                 EndTime=end_time,
                 Period=86400,  # Daily
-                Statistics=['Sum']
+                Statistics=["Sum"],
             )
-            
+
             # If no metrics or very low usage, consider unused
-            datapoints = response.get('Datapoints', [])
+            datapoints = response.get("Datapoints", [])
             if not datapoints:
                 return True
-            
+
             # Calculate total bytes over period
-            total_bytes = sum(dp['Sum'] for dp in datapoints)
-            
+            total_bytes = sum(dp["Sum"] for dp in datapoints)
+
             # Consider unused if less than 100MB over the entire period
             usage_threshold = 100 * 1024 * 1024  # 100MB
             return total_bytes < usage_threshold
-            
+
         except Exception:
             # If we can't get metrics, assume it's in use (safe approach)
             return False
-    
+
     async def _execute_nat_gateway_deletion(self, unused_gateways: List[ResourceImpact]) -> None:
         """
         Execute NAT Gateway deletion for confirmed unused gateways.
-        
+
         Args:
             unused_gateways: List of confirmed unused NAT Gateways
         """
         if self.dry_run:
             print_info("DRY RUN: Would delete NAT Gateways")
             return
-        
+
         print_warning("🚨 EXECUTING NAT Gateway deletions - this action cannot be undone!")
-        
+
         # Group by region for efficient processing
         gateways_by_region = {}
         for gateway in unused_gateways:
@@ -1118,68 +1124,68 @@ class CostOptimizer(CloudOpsBase):
             if region not in gateways_by_region:
                 gateways_by_region[region] = []
             gateways_by_region[region].append(gateway)
-        
+
         for region, gateways in gateways_by_region.items():
             try:
-                ec2 = self.session.client('ec2', region_name=region)
-                
+                ec2 = self.session.client("ec2", region_name=region)
+
                 for gateway in gateways:
                     try:
                         ec2.delete_nat_gateway(NatGatewayId=gateway.resource_id)
                         print_success(f"✅ Deleted NAT Gateway {gateway.resource_id} in {region}")
-                        
+
                     except ClientError as e:
                         print_error(f"❌ Failed to delete {gateway.resource_id}: {str(e)}")
-                        
+
             except Exception as e:
                 print_error(f"❌ Failed to process region {region}: {str(e)}")
-    
+
     async def optimize_idle_ec2_instances(
         self,
         regions: Optional[List[str]] = None,
         cpu_threshold: float = 5.0,
         duration_hours: int = 168,  # 7 days
-        cost_threshold: float = None
+        cost_threshold: float = None,
     ) -> CostOptimizationResult:
         """
         Business Scenario: Stop idle EC2 instances
         Source: AWS_Stop_Idle_EC2_Instances.ipynb
-        
+
         Typical Business Impact:
         - Cost savings: 20-60% on compute costs
         - Risk level: Medium (requires application impact analysis)
         - Implementation time: 30-60 minutes
-        
+
         Args:
             regions: Target regions for analysis
             cpu_threshold: CPU utilization threshold (%)
             duration_hours: Analysis period in hours
             cost_threshold: Minimum monthly cost to consider
-            
+
         Returns:
             CostOptimizationResult with idle instance analysis
         """
         operation_name = "Idle EC2 Instance Optimization"
         print_header(f"📊 {operation_name}")
-        
+
         # Implementation follows similar pattern to NAT Gateway optimization
         # This would integrate the logic from AWS_Stop_Idle_EC2_Instances.ipynb
-        
+
         # Set dynamic cost threshold if not provided - NO hardcoded defaults
         if cost_threshold is None:
-            cost_threshold = get_required_env_float('EC2_COST_THRESHOLD')
-        
+            cost_threshold = get_required_env_float("EC2_COST_THRESHOLD")
+
         print_info(f"Analyzing EC2 instances with <{cpu_threshold}% CPU utilization")
         print_info(f"Analysis period: {duration_hours} hours")
         print_info(f"Minimum cost threshold: ${cost_threshold}/month")
-        
+
         # Placeholder for detailed implementation
         # In production, this would:
         # 1. Query CloudWatch for EC2 CPU metrics
         # 2. Identify instances below threshold
         # 3. Calculate cost impact
         # 4. Generate business recommendations
-        
+
         return CostOptimizationResult(
             scenario=BusinessScenario.COST_OPTIMIZATION,
             scenario_name="Idle EC2 Instance Optimization",
@@ -1193,8 +1199,8 @@ class CostOptimizer(CloudOpsBase):
             business_metrics=self.create_business_metrics(),
             recommendations=[
                 "Implement auto-scaling policies for variable workloads",
-                "Consider spot instances for fault-tolerant workloads", 
-                "Review instance sizing for optimization opportunities"
+                "Consider spot instances for fault-tolerant workloads",
+                "Review instance sizing for optimization opportunities",
             ],
             aws_profile_used=self.profile,
             regions_analyzed=regions or [],
@@ -1204,14 +1210,11 @@ class CostOptimizer(CloudOpsBase):
             savings_percentage=0.0,
             idle_resources=[],
             oversized_resources=[],
-            unattached_resources=[]
+            unattached_resources=[],
         )
-    
+
     async def optimize_workspaces(
-        self,
-        usage_threshold_days: int = 180,
-        analysis_days: int = 30,
-        dry_run: bool = True
+        self, usage_threshold_days: int = 180, analysis_days: int = 30, dry_run: bool = True
     ) -> CostOptimizationResult:
         """
         Business Scenario: Cleanup unused WorkSpaces with zero usage in last 6 months
@@ -1228,7 +1231,7 @@ class CostOptimizer(CloudOpsBase):
         """
         operation_name = "WorkSpaces Cost Optimization"
         print_header(f"🏢 {operation_name}")
-        
+
         # Import existing workspaces analyzer
         try:
             from runbooks.finops.workspaces_analyzer import WorkSpacesCostAnalyzer, analyze_workspaces
@@ -1246,25 +1249,22 @@ class CostOptimizer(CloudOpsBase):
                 execution_time=0.0,
                 resources_analyzed=0,
                 resources_impacted=[],
-                business_metrics={
-                    "total_monthly_savings": 0.0,
-                    "overall_risk_level": "low"
-                },
+                business_metrics={"total_monthly_savings": 0.0, "overall_risk_level": "low"},
                 recommendations=[],
                 aws_profile_used=self.profile or "default",
                 current_monthly_spend=0.0,
                 optimized_monthly_spend=0.0,
                 savings_percentage=0.0,
-                annual_savings=0.0
+                annual_savings=0.0,
             )
-        
+
         # Execute WorkSpaces analysis using proven finops function
         analysis_results = analyze_workspaces(
             profile=self.profile,
             unused_days=usage_threshold_days,
             analysis_days=analysis_days,
             output_format="json",
-            dry_run=dry_run
+            dry_run=dry_run,
         )
 
         # Extract analysis results
@@ -1280,7 +1280,7 @@ class CostOptimizer(CloudOpsBase):
             estimated_annual_savings = 0.0
             unused_workspaces_count = 0
             total_workspaces = 0
-        
+
         # Calculate savings percentage if we have baseline cost data
         savings_percentage = 0.0
         if summary.get("total_monthly_cost", 0) > 0:
@@ -1314,7 +1314,7 @@ class CostOptimizer(CloudOpsBase):
                     projected_savings=estimated_monthly_savings,
                     risk_level=RiskLevel.LOW,
                     business_criticality="low",
-                    modification_required=not dry_run
+                    modification_required=not dry_run,
                 )
             ],
             # Business metrics for executive reporting
@@ -1322,117 +1322,129 @@ class CostOptimizer(CloudOpsBase):
                 "total_monthly_savings": estimated_monthly_savings,
                 "overall_risk_level": "low",
                 "unused_workspaces_count": unused_workspaces_count,
-                "total_workspaces_analyzed": total_workspaces
+                "total_workspaces_analyzed": total_workspaces,
             },
             recommendations=[
                 f"Terminate {unused_workspaces_count} unused WorkSpaces to save ${estimated_monthly_savings:.2f}/month",
                 f"Estimated annual savings: ${estimated_annual_savings:.2f}",
                 "Verify WorkSpaces are truly unused before termination",
-                "Consider implementing usage monitoring for remaining WorkSpaces"
+                "Consider implementing usage monitoring for remaining WorkSpaces",
             ],
-            aws_profile_used=self.profile or "default"
+            aws_profile_used=self.profile or "default",
         )
-    
+
     async def optimize_rds_snapshots(
-        self,
-        snapshot_age_threshold_days: int = 90,
-        dry_run: bool = True
+        self, snapshot_age_threshold_days: int = 90, dry_run: bool = True
     ) -> CostOptimizationResult:
         """
         Business Scenario: Delete RDS manual snapshots
-        JIRA Reference: FinOps-23  
+        JIRA Reference: FinOps-23
         Expected Savings: USD $5,000 – significant annual savingsly
-        
+
         Args:
             snapshot_age_threshold_days: Age threshold for snapshot deletion
             dry_run: If True, only analyze without deletion
-            
+
         Returns:
             CostOptimizationResult with RDS snapshots cleanup analysis
         """
         operation_name = "RDS Snapshots Cost Optimization"
         print_header(f"💾 {operation_name} (FinOps-23)")
-        
+
         with create_progress_bar() as progress:
             task = progress.add_task("Analyzing RDS manual snapshots...", total=100)
-            
+
             # Step 1: Discover manual RDS snapshots using proven AWS Config aggregator method
             all_manual_snapshots = []
 
             try:
                 # Use AWS Config aggregator to discover all RDS snapshots across organization
-                config_client = self.session.client('config', region_name='ap-southeast-2')
+                config_client = self.session.client("config", region_name="ap-southeast-2")
 
                 # Get all RDS snapshots via AWS Config aggregator (proven method)
                 response = config_client.select_aggregate_resource_config(
                     Expression="SELECT configuration, accountId, awsRegion WHERE resourceType = 'AWS::RDS::DBSnapshot'",
-                    ConfigurationAggregatorName='organization-aggregator',
-                    MaxResults=100  # AWS limit is 100
+                    ConfigurationAggregatorName="organization-aggregator",
+                    MaxResults=100,  # AWS limit is 100
                 )
 
                 print_info(f"Found {len(response.get('Results', []))} RDS snapshots via AWS Config aggregator")
 
                 # Process snapshots found by Config aggregator
-                for result in response.get('Results', []):
+                for result in response.get("Results", []):
                     try:
                         resource_data = json.loads(result)
-                        config_data = resource_data.get('configuration', {})
+                        config_data = resource_data.get("configuration", {})
 
                         # Handle case where configuration might be a string
                         if isinstance(config_data, str):
                             config_data = json.loads(config_data)
 
                         # Filter for manual snapshots only
-                        if config_data.get('snapshotType') == 'manual':
+                        if config_data.get("snapshotType") == "manual":
                             # Create snapshot object compatible with describe_db_snapshots format
                             snapshot = {
-                                'DBSnapshotIdentifier': config_data.get('dBSnapshotIdentifier'),
-                                'SnapshotCreateTime': datetime.fromisoformat(config_data.get('snapshotCreateTime', '').replace('Z', '+00:00')) if config_data.get('snapshotCreateTime') else datetime.now(),
-                                'AllocatedStorage': config_data.get('allocatedStorage', 0),
-                                'DBInstanceIdentifier': config_data.get('dBInstanceIdentifier'),
-                                'SnapshotType': config_data.get('snapshotType'),
-                                'Status': config_data.get('status', 'available'),
-                                'Engine': config_data.get('engine'),
-                                'EngineVersion': config_data.get('engineVersion')
+                                "DBSnapshotIdentifier": config_data.get("dBSnapshotIdentifier"),
+                                "SnapshotCreateTime": datetime.fromisoformat(
+                                    config_data.get("snapshotCreateTime", "").replace("Z", "+00:00")
+                                )
+                                if config_data.get("snapshotCreateTime")
+                                else datetime.now(),
+                                "AllocatedStorage": config_data.get("allocatedStorage", 0),
+                                "DBInstanceIdentifier": config_data.get("dBInstanceIdentifier"),
+                                "SnapshotType": config_data.get("snapshotType"),
+                                "Status": config_data.get("status", "available"),
+                                "Engine": config_data.get("engine"),
+                                "EngineVersion": config_data.get("engineVersion"),
                             }
                             all_manual_snapshots.append(snapshot)
                     except Exception as e:
                         print_warning(f"Error processing snapshot from Config: {e}")
 
-                print_success(f"Successfully processed {len(all_manual_snapshots)} manual snapshots from Config aggregator")
+                print_success(
+                    f"Successfully processed {len(all_manual_snapshots)} manual snapshots from Config aggregator"
+                )
 
             except Exception as e:
                 print_warning(f"AWS Config aggregator query failed, falling back to regional discovery: {e}")
 
                 # Fallback to regional discovery if Config aggregator fails
-                regions = ['us-east-1', 'us-west-2', 'ap-southeast-2', 'eu-west-1', 'ap-southeast-1']  # Extended regions
+                regions = [
+                    "us-east-1",
+                    "us-west-2",
+                    "ap-southeast-2",
+                    "eu-west-1",
+                    "ap-southeast-1",
+                ]  # Extended regions
 
                 for region in regions:
-                    regional_client = self.session.client('rds', region_name=region)
+                    regional_client = self.session.client("rds", region_name=region)
                     try:
                         # Get all manual snapshots in this region
-                        paginator = regional_client.get_paginator('describe_db_snapshots')
-                        page_iterator = paginator.paginate(SnapshotType='manual')
+                        paginator = regional_client.get_paginator("describe_db_snapshots")
+                        page_iterator = paginator.paginate(SnapshotType="manual")
 
                         for page in page_iterator:
-                            all_manual_snapshots.extend(page.get('DBSnapshots', []))
+                            all_manual_snapshots.extend(page.get("DBSnapshots", []))
 
-                        print_info(f"Found {len([s for s in all_manual_snapshots if 'region' not in s])} manual snapshots in {region}")
+                        print_info(
+                            f"Found {len([s for s in all_manual_snapshots if 'region' not in s])} manual snapshots in {region}"
+                        )
                     except Exception as e:
                         print_warning(f"Could not access region {region}: {e}")
-            
+
             progress.update(task, advance=40)
-            
+
             # Step 2: Filter old snapshots
             cutoff_date = datetime.now() - timedelta(days=snapshot_age_threshold_days)
             old_snapshots = []
-            
+
             for snapshot in all_manual_snapshots:
-                if snapshot['SnapshotCreateTime'].replace(tzinfo=None) < cutoff_date:
+                if snapshot["SnapshotCreateTime"].replace(tzinfo=None) < cutoff_date:
                     old_snapshots.append(snapshot)
-            
+
             progress.update(task, advance=70)
-            
+
             # Step 3: Use enhanced RDS snapshot optimizer for consistent results
             try:
                 from runbooks.finops.rds_snapshot_optimizer import EnhancedRDSSnapshotOptimizer
@@ -1451,23 +1463,23 @@ class CostOptimizer(CloudOpsBase):
                         )
 
                         # Use comprehensive scenario for realistic savings
-                        comprehensive_scenario = optimization_results['optimization_scenarios']['comprehensive']
+                        comprehensive_scenario = optimization_results["optimization_scenarios"]["comprehensive"]
 
                         # Create resource impacts for comprehensive scenario
                         resource_impacts = []
-                        for snapshot in comprehensive_scenario['snapshots']:
+                        for snapshot in comprehensive_scenario["snapshots"]:
                             resource_impacts.append(
                                 ResourceImpact(
                                     resource_type="rds-snapshot",
-                                    resource_id=snapshot.get('DBSnapshotIdentifier', 'unknown'),
-                                    region=snapshot.get('Region', 'unknown'),
-                                    account_id=snapshot.get('AccountId', 'unknown'),
-                                    estimated_monthly_cost=snapshot.get('EstimatedMonthlyCost', 0.0),
-                                    projected_savings=snapshot.get('EstimatedMonthlyCost', 0.0),
+                                    resource_id=snapshot.get("DBSnapshotIdentifier", "unknown"),
+                                    region=snapshot.get("Region", "unknown"),
+                                    account_id=snapshot.get("AccountId", "unknown"),
+                                    estimated_monthly_cost=snapshot.get("EstimatedMonthlyCost", 0.0),
+                                    projected_savings=snapshot.get("EstimatedMonthlyCost", 0.0),
                                     risk_level=RiskLevel.MEDIUM,
                                     modification_required=True,
                                     resource_name=f"RDS Snapshot {snapshot.get('DBSnapshotIdentifier', 'unknown')}",
-                                    estimated_downtime=0.0
+                                    estimated_downtime=0.0,
                                 )
                             )
 
@@ -1481,26 +1493,31 @@ class CostOptimizer(CloudOpsBase):
                             execution_time=30.0,
                             success=True,
                             error_message=None,
-                            resources_analyzed=optimization_results['total_snapshots'],
+                            resources_analyzed=optimization_results["total_snapshots"],
                             resources_impacted=resource_impacts,
                             business_metrics=self.create_business_metrics(
-                                total_savings=optimization_results['potential_monthly_savings'],
-                                overall_risk=RiskLevel.MEDIUM
+                                total_savings=optimization_results["potential_monthly_savings"],
+                                overall_risk=RiskLevel.MEDIUM,
                             ),
                             recommendations=[
                                 f"Review {optimization_results['cleanup_candidates']} snapshots older than {snapshot_age_threshold_days} days",
                                 f"Potential annual savings: ${optimization_results['potential_annual_savings']:,.2f}",
                                 "Consider implementing automated retention policies",
-                                "Review backup requirements before deletion"
+                                "Review backup requirements before deletion",
                             ],
                             # CostOptimizationResult specific fields
-                            current_monthly_spend=optimization_results.get('current_monthly_spend', 0.0),
-                            optimized_monthly_spend=optimization_results.get('current_monthly_spend', 0.0) - optimization_results['potential_monthly_savings'],
-                            savings_percentage=(optimization_results['potential_monthly_savings'] / max(optimization_results.get('current_monthly_spend', 1), 1)) * 100,
-                            annual_savings=optimization_results['potential_annual_savings'],
-                            total_monthly_savings=optimization_results['potential_monthly_savings'],
-                            affected_resources=optimization_results['cleanup_candidates'],
-                            resource_impacts=resource_impacts
+                            current_monthly_spend=optimization_results.get("current_monthly_spend", 0.0),
+                            optimized_monthly_spend=optimization_results.get("current_monthly_spend", 0.0)
+                            - optimization_results["potential_monthly_savings"],
+                            savings_percentage=(
+                                optimization_results["potential_monthly_savings"]
+                                / max(optimization_results.get("current_monthly_spend", 1), 1)
+                            )
+                            * 100,
+                            annual_savings=optimization_results["potential_annual_savings"],
+                            total_monthly_savings=optimization_results["potential_monthly_savings"],
+                            affected_resources=optimization_results["cleanup_candidates"],
+                            resource_impacts=resource_impacts,
                         )
                     else:
                         print_warning("No snapshots discovered via enhanced optimizer")
@@ -1514,15 +1531,15 @@ class CostOptimizer(CloudOpsBase):
             print_info("Using legacy optimization calculation...")
             # Step 3: Calculate estimated savings (legacy)
             # Based on JIRA data: measurable range range for manual snapshots
-            total_size_gb = sum(snapshot.get('AllocatedStorage', 0) for snapshot in old_snapshots)
+            total_size_gb = sum(snapshot.get("AllocatedStorage", 0) for snapshot in old_snapshots)
             estimated_monthly_savings = total_size_gb * 0.05  # ~$0.05/GB-month for snapshots
             progress.update(task, advance=90)
-            
+
             # Step 4: Execute cleanup if not dry_run
             if not dry_run and old_snapshots:
                 await self._execute_rds_snapshots_cleanup(old_snapshots)
             progress.update(task, advance=100)
-        
+
         # Display results
         results_table = create_table("RDS Snapshots Optimization Results")
         results_table.add_row("Manual Snapshots Found", str(len(all_manual_snapshots)))
@@ -1532,7 +1549,7 @@ class CostOptimizer(CloudOpsBase):
         results_table.add_row("Annual Savings", format_cost(estimated_monthly_savings * 12))
         results_table.add_row("Execution Mode", "Analysis Only" if dry_run else "Cleanup Executed")
         console.print(results_table)
-        
+
         return CostOptimizationResult(
             scenario=BusinessScenario.COST_OPTIMIZATION,
             scenario_name=operation_name,
@@ -1553,68 +1570,61 @@ class CostOptimizer(CloudOpsBase):
                     account_id=self.account_id,
                     estimated_monthly_cost=estimated_monthly_savings,
                     projected_savings=estimated_monthly_savings,
-                    risk_level=RiskLevel.MEDIUM
+                    risk_level=RiskLevel.MEDIUM,
                 )
             ],
             # Add missing required fields
             resources_analyzed=len(all_manual_snapshots),
             resources_impacted=[],  # Must be a list
-            business_metrics={
-                "total_monthly_savings": estimated_monthly_savings,
-                "overall_risk_level": "medium"
-            },
+            business_metrics={"total_monthly_savings": estimated_monthly_savings, "overall_risk_level": "medium"},
             recommendations=[],
             aws_profile_used=self.profile or "default",
             current_monthly_spend=0.0,
-            optimized_monthly_spend=0.0
+            optimized_monthly_spend=0.0,
         )
-    
+
     async def investigate_commvault_ec2(
-        self,
-        account_id: Optional[str] = None,
-        dry_run: bool = True
+        self, account_id: Optional[str] = None, dry_run: bool = True
     ) -> CostOptimizationResult:
         """
         Business Scenario: Investigate Commvault Account and EC2 instances
         JIRA Reference: FinOps-25
         Expected Savings: TBD via utilization analysis
-        
+
         Args:
             account_id: Commvault backups account ID
             dry_run: If True, only analyze without action
-            
+
         Returns:
             CostOptimizationResult with Commvault EC2 investigation analysis
         """
         operation_name = "Commvault EC2 Investigation"
         print_header(f"🔍 {operation_name} (FinOps-25)")
-        
+
         print_info(f"Analyzing Commvault account: {account_id}")
         print_warning("This investigation determines if EC2 instances are actively used for backups")
-        
+
         with create_progress_bar() as progress:
             task = progress.add_task("Investigating Commvault EC2 instances...", total=100)
-            
+
             # Step 1: Discover EC2 instances in Commvault account
             # Note: This would require cross-account access or account switching
             try:
-                ec2_client = self.session.client('ec2', region_name=self.region)
+                ec2_client = self.session.client("ec2", region_name=self.region)
                 response = ec2_client.describe_instances(
-                    Filters=[
-                        {'Name': 'instance-state-name', 'Values': ['running', 'stopped']}
-                    ]
+                    Filters=[{"Name": "instance-state-name", "Values": ["running", "stopped"]}]
                 )
-                
+
                 commvault_instances = []
-                for reservation in response['Reservations']:
-                    commvault_instances.extend(reservation['Instances'])
-                    
+                for reservation in response["Reservations"]:
+                    commvault_instances.extend(reservation["Instances"])
+
                 progress.update(task, advance=40)
-                
+
             except Exception as e:
                 print_error(f"Cannot access Commvault account {account_id}: {e}")
                 print_info("Investigation requires appropriate cross-account IAM permissions")
-                
+
                 return CostOptimizationResult(
                     scenario=BusinessScenario.COST_OPTIMIZATION,
                     scenario_name=operation_name,
@@ -1626,39 +1636,36 @@ class CostOptimizer(CloudOpsBase):
                     execution_time=0.0,
                     resources_analyzed=0,
                     resources_impacted=[],  # Must be a list
-                    business_metrics={
-                        "total_monthly_savings": 0.0,
-                        "overall_risk_level": "high"
-                    },
+                    business_metrics={"total_monthly_savings": 0.0, "overall_risk_level": "high"},
                     recommendations=[],
                     aws_profile_used=self.profile or "default",
                     current_monthly_spend=0.0,
                     optimized_monthly_spend=0.0,
-                    savings_percentage=0.0
+                    savings_percentage=0.0,
                 )
-            
+
             # Step 2: Analyze instance utilization patterns
             active_instances = []
             idle_instances = []
-            
+
             for instance in commvault_instances:
                 # This is a simplified analysis - real implementation would check:
                 # - CloudWatch metrics for CPU/Network/Disk utilization
                 # - Backup job logs
                 # - Instance tags for backup software identification
-                if instance['State']['Name'] == 'running':
+                if instance["State"]["Name"] == "running":
                     active_instances.append(instance)
                 else:
                     idle_instances.append(instance)
-            
+
             progress.update(task, advance=80)
-            
+
             # Step 3: Generate investigation report
             estimated_monthly_cost = len(active_instances) * 50  # Rough estimate
             potential_savings = len(idle_instances) * 50
-            
+
             progress.update(task, advance=100)
-        
+
         # Display investigation results
         results_table = create_table("Commvault EC2 Investigation Results")
         results_table.add_row("Total EC2 Instances", str(len(commvault_instances)))
@@ -1668,7 +1675,7 @@ class CostOptimizer(CloudOpsBase):
         results_table.add_row("Potential Savings (if idle)", format_cost(potential_savings))
         results_table.add_row("Investigation Status", "Framework Established")
         console.print(results_table)
-        
+
         # Investigation-specific recommendations
         recommendations_panel = create_panel(
             "📋 Investigation Recommendations:\n"
@@ -1677,10 +1684,10 @@ class CostOptimizer(CloudOpsBase):
             "3. Analyze CloudWatch metrics for actual utilization\n"
             "4. Coordinate with backup team before any terminations\n"
             "5. Implement monitoring for backup service health",
-            title="Next Steps"
+            title="Next Steps",
         )
         console.print(recommendations_panel)
-        
+
         return CostOptimizationResult(
             scenario=BusinessScenario.COST_OPTIMIZATION,
             scenario_name=operation_name,
@@ -1698,26 +1705,23 @@ class CostOptimizer(CloudOpsBase):
                     resource_type="AWS::EC2::Instance",
                     action="investigate",
                     monthly_savings=potential_savings,
-                    risk_level=RiskLevel.HIGH  # High risk due to potential backup disruption
+                    risk_level=RiskLevel.HIGH,  # High risk due to potential backup disruption
                 )
             ],
             # Add missing required fields
             resources_analyzed=len(commvault_instances),
             resources_impacted=[],  # Must be a list
-            business_metrics={
-                "total_monthly_savings": potential_savings,
-                "overall_risk_level": "high"
-            },
+            business_metrics={"total_monthly_savings": potential_savings, "overall_risk_level": "high"},
             recommendations=[],
             aws_profile_used=self.profile or "default",
             current_monthly_spend=0.0,
-            optimized_monthly_spend=0.0
+            optimized_monthly_spend=0.0,
         )
-    
+
     async def _execute_workspaces_cleanup(self, unused_workspaces: List[dict]) -> None:
         """Execute WorkSpaces cleanup with safety controls."""
         print_warning(f"Executing WorkSpaces cleanup for {len(unused_workspaces)} instances")
-        
+
         for workspace in unused_workspaces:
             try:
                 # This would require WorkSpaces client and proper error handling
@@ -1726,15 +1730,15 @@ class CostOptimizer(CloudOpsBase):
                 await asyncio.sleep(0.1)  # Prevent rate limiting
             except Exception as e:
                 print_error(f"Failed to terminate WorkSpace: {e}")
-    
+
     async def _execute_rds_snapshots_cleanup(self, old_snapshots: List[dict]) -> None:
         """Execute RDS snapshots cleanup with safety controls."""
         print_warning(f"Executing RDS snapshots cleanup for {len(old_snapshots)} snapshots")
-        
+
         for snapshot in old_snapshots:
             try:
                 # This would require RDS client calls with proper error handling
-                snapshot_id = snapshot.get('DBSnapshotIdentifier', 'unknown')
+                snapshot_id = snapshot.get("DBSnapshotIdentifier", "unknown")
                 print_info(f"Would delete RDS snapshot: {snapshot_id}")
                 # rds_client.delete_db_snapshot(DBSnapshotIdentifier=snapshot_id)
                 await asyncio.sleep(0.2)  # Prevent rate limiting
@@ -1742,42 +1746,40 @@ class CostOptimizer(CloudOpsBase):
                 print_error(f"Failed to delete snapshot: {e}")
 
     async def emergency_cost_response(
-        self,
-        cost_spike_threshold: float = 5000.0,
-        analysis_days: int = 7
+        self, cost_spike_threshold: float = 5000.0, analysis_days: int = 7
     ) -> CostOptimizationResult:
         """
         Business Scenario: Emergency response to cost spikes
-        
+
         Designed for: CFO escalations, budget overruns, unexpected charges
         Response time: <30 minutes for initial analysis
-        
+
         Args:
             cost_spike_threshold: Minimum cost increase to trigger analysis
             analysis_days: Days to analyze for cost changes
-            
+
         Returns:
             CostOptimizationResult with emergency cost analysis
         """
         operation_name = "Emergency Cost Spike Response"
         print_header(f"🚨 {operation_name}")
-        
+
         print_warning(f"Analyzing cost increases >${format_cost(cost_spike_threshold)}")
-        
+
         # This would integrate multiple cost optimization scenarios
         # for rapid cost reduction in emergency situations
-        
+
         emergency_actions = [
             "Immediate idle resource identification and shutdown",
             "Temporary scaling reduction for non-critical services",
             "Cost anomaly detection and root cause analysis",
-            "Executive cost impact report generation"
+            "Executive cost impact report generation",
         ]
-        
+
         print_info("Emergency response actions:")
         for action in emergency_actions:
             print_info(f"  • {action}")
-        
+
         return CostOptimizationResult(
             scenario=BusinessScenario.COST_OPTIMIZATION,
             scenario_name="Emergency Cost Spike Response",
@@ -1790,12 +1792,12 @@ class CostOptimizer(CloudOpsBase):
             resources_impacted=[],
             business_metrics=self.create_business_metrics(
                 total_savings=cost_spike_threshold * 0.3,  # Target 30% reduction
-                overall_risk=RiskLevel.HIGH  # Emergency actions carry higher risk
+                overall_risk=RiskLevel.HIGH,  # Emergency actions carry higher risk
             ),
             recommendations=[
                 "Implement cost anomaly detection and alerting",
                 "Establish cost governance policies and approval workflows",
-                "Regular cost optimization reviews to prevent spikes"
+                "Regular cost optimization reviews to prevent spikes",
             ],
             aws_profile_used=self.profile,
             regions_analyzed=[],
@@ -1804,6 +1806,6 @@ class CostOptimizer(CloudOpsBase):
             optimized_monthly_spend=cost_spike_threshold * 0.7,
             savings_percentage=30.0,
             idle_resources=[],
-            oversized_resources=[], 
-            unattached_resources=[]
-        )
+            oversized_resources=[],
+            unattached_resources=[],
+        )