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

runbooks/finops/cost_optimizer.py

@@ -14,22 +14,31 @@ Input: region, idle_cpu_threshold, idle_duration, instance_ids (optional)
 Output: List of stopped instances and cost impact analysis
 """
 
-from typing import Dict, List, Optional, Tuple, Any
 import datetime
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
+
 import boto3
 from botocore.exceptions import ClientError
 from pydantic import BaseModel, Field
-from dataclasses import dataclass
 
+from ..common.aws_pricing import DynamicAWSPricing
 from ..common.rich_utils import (
-    console, print_header, print_success, print_error, print_warning,
-    create_table, create_progress_bar, format_cost
+    console,
+    create_progress_bar,
+    create_table,
+    format_cost,
+    print_error,
+    print_header,
+    print_success,
+    print_warning,
 )
-from ..common.aws_pricing import DynamicAWSPricing
+
 
 @dataclass
 class IdleInstance:
     """Data class for idle EC2 instances"""
+
     instance_id: str
     region: str
     instance_type: str = ""
@@ -37,9 +46,11 @@ class IdleInstance:
     estimated_monthly_cost: float = 0.0
     tags: Dict[str, str] = Field(default_factory=dict)
 
+
 @dataclass
 class LowUsageVolume:
     """Data class for low usage EBS volumes"""
+
     volume_id: str
     region: str
     volume_type: str = ""
@@ -49,9 +60,11 @@ class LowUsageVolume:
     creation_date: Optional[str] = None
     tags: Dict[str, str] = Field(default_factory=dict)
 
+
 @dataclass
 class UnusedNATGateway:
     """Data class for unused NAT Gateways"""
+
     nat_gateway_id: str
     region: str
     vpc_id: str = ""
@@ -60,70 +73,67 @@ class UnusedNATGateway:
     creation_date: Optional[str] = None
     tags: Dict[str, str] = Field(default_factory=dict)
 
+
 @dataclass
 class CostOptimizationResult:
     """Results from cost optimization operations"""
+
     stopped_instances: List[IdleInstance] = Field(default_factory=list)
     deleted_volumes: List[LowUsageVolume] = Field(default_factory=list)
     deleted_nat_gateways: List[UnusedNATGateway] = Field(default_factory=list)
     total_potential_savings: float = 0.0
     annual_savings: float = 0.0  # Annual savings projection for business scenarios
     execution_summary: Dict[str, Any] = Field(default_factory=dict)
-    
+
+
 class AWSCostOptimizer:
     """
     Enterprise AWS Cost Optimization
     Migrated and enhanced from unSkript notebooks
     Handles EC2 instances, EBS volumes, and other cost optimization scenarios
     """
-    
+
     def __init__(self, profile: Optional[str] = None):
         self.profile = profile
         self.session = boto3.Session(profile_name=profile) if profile else boto3.Session()
-        
+
     def find_idle_instances(
-        self,
-        region: str = "",
-        idle_cpu_threshold: int = 5,
-        idle_duration: int = 6
+        self, region: str = "", idle_cpu_threshold: int = 5, idle_duration: int = 6
     ) -> Tuple[bool, Optional[List[IdleInstance]]]:
         """
         Find idle EC2 instances based on CPU utilization
-        
+
         Migrated from: AWS_Stop_Idle_EC2_Instances.ipynb
-        
+
         Args:
             region: AWS Region to scan (empty for all regions)
             idle_cpu_threshold: CPU threshold percentage (default 5%)
             idle_duration: Duration in hours to check (default 6h)
-            
+
         Returns:
             Tuple (success, list_of_idle_instances)
         """
         print_header("Cost Optimizer - Idle Instance Detection", "latest version")
-        
+
         result = []
         regions_to_check = [region] if region else self._get_all_regions()
-        
+
         with create_progress_bar() as progress:
             task_id = progress.add_task(
-                f"Scanning {len(regions_to_check)} regions for idle instances...",
-                total=len(regions_to_check)
+                f"Scanning {len(regions_to_check)} regions for idle instances...", total=len(regions_to_check)
             )
-            
+
             for reg in regions_to_check:
                 try:
-                    idle_instances = self._scan_region_for_idle_instances(
-                        reg, idle_cpu_threshold, idle_duration
-                    )
+                    idle_instances = self._scan_region_for_idle_instances(reg, idle_cpu_threshold, idle_duration)
                     result.extend(idle_instances)
                     progress.advance(task_id)
-                    
+
                 except Exception as e:
                     print_warning(f"Failed to scan region {reg}: {str(e)}")
                     progress.advance(task_id)
                     continue
-        
+
         if result:
             print_success(f"Found {len(result)} idle instances across {len(regions_to_check)} regions")
             self._display_idle_instances_table(result)
@@ -131,70 +141,59 @@ class AWSCostOptimizer:
         else:
             print_success("No idle instances found")
             return (True, None)  # True = no results (unSkript convention)
-    
+
     def _scan_region_for_idle_instances(
-        self,
-        region: str,
-        idle_cpu_threshold: int,
-        idle_duration: int
+        self, region: str, idle_cpu_threshold: int, idle_duration: int
     ) -> List[IdleInstance]:
         """Scan a specific region for idle instances"""
-        
+
         result = []
-        
+
         try:
-            ec2_client = self.session.client('ec2', region_name=region)
-            cloudwatch_client = self.session.client('cloudwatch', region_name=region)
-            
+            ec2_client = self.session.client("ec2", region_name=region)
+            cloudwatch_client = self.session.client("cloudwatch", region_name=region)
+
             # Get all running instances
-            response = ec2_client.describe_instances(
-                Filters=[{'Name': 'instance-state-name', 'Values': ['running']}]
-            )
-            
-            for reservation in response['Reservations']:
-                for instance in reservation['Instances']:
-                    instance_id = instance['InstanceId']
-                    
-                    if self._is_instance_idle(
-                        instance_id, idle_cpu_threshold, idle_duration, cloudwatch_client
-                    ):
+            response = ec2_client.describe_instances(Filters=[{"Name": "instance-state-name", "Values": ["running"]}])
+
+            for reservation in response["Reservations"]:
+                for instance in reservation["Instances"]:
+                    instance_id = instance["InstanceId"]
+
+                    if self._is_instance_idle(instance_id, idle_cpu_threshold, idle_duration, cloudwatch_client):
                         # Extract tags
-                        tags = {tag['Key']: tag['Value'] for tag in instance.get('Tags', [])}
-                        
+                        tags = {tag["Key"]: tag["Value"] for tag in instance.get("Tags", [])}
+
                         idle_instance = IdleInstance(
                             instance_id=instance_id,
                             region=region,
-                            instance_type=instance.get('InstanceType', 'unknown'),
-                            tags=tags
+                            instance_type=instance.get("InstanceType", "unknown"),
+                            tags=tags,
                         )
-                        
+
                         # Calculate estimated cost (simplified - real implementation would use pricing API)
                         idle_instance.estimated_monthly_cost = self._estimate_instance_monthly_cost(
-                            instance.get('InstanceType', 't3.micro')
+                            instance.get("InstanceType", "t3.micro")
                         )
-                        
+
                         result.append(idle_instance)
-                        
+
         except ClientError as e:
             print_warning(f"AWS API error in region {region}: {e}")
         except Exception as e:
             print_error(f"Unexpected error in region {region}: {e}")
-            
+
         return result
-    
+
     def _is_instance_idle(
-        self,
-        instance_id: str,
-        idle_cpu_threshold: int,
-        idle_duration: int,
-        cloudwatch_client
+        self, instance_id: str, idle_cpu_threshold: int, idle_duration: int, cloudwatch_client
     ) -> bool:
         """Check if instance is idle based on CPU metrics"""
-        
+
         try:
             now = datetime.datetime.utcnow()
             start_time = now - datetime.timedelta(hours=idle_duration)
-            
+
             cpu_stats = cloudwatch_client.get_metric_statistics(
                 Namespace="AWS/EC2",
                 MetricName="CPUUtilization",
@@ -202,142 +201,121 @@ class AWSCostOptimizer:
                 StartTime=start_time,
                 EndTime=now,
                 Period=3600,  # 1 hour periods
-                Statistics=["Average"]
+                Statistics=["Average"],
             )
-            
+
             if not cpu_stats["Datapoints"]:
                 return False  # No metrics = not idle (may be new instance)
-            
+
             # Calculate average CPU across all data points
-            avg_cpu = sum(
-                datapoint["Average"] for datapoint in cpu_stats["Datapoints"]
-            ) / len(cpu_stats["Datapoints"])
-            
+            avg_cpu = sum(datapoint["Average"] for datapoint in cpu_stats["Datapoints"]) / len(cpu_stats["Datapoints"])
+
             return avg_cpu < idle_cpu_threshold
-            
+
         except Exception as e:
             print_warning(f"Could not get metrics for {instance_id}: {e}")
             return False
-    
-    def stop_idle_instances(
-        self,
-        idle_instances: List[IdleInstance],
-        dry_run: bool = True
-    ) -> CostOptimizationResult:
+
+    def stop_idle_instances(self, idle_instances: List[IdleInstance], dry_run: bool = True) -> CostOptimizationResult:
         """
         Stop idle EC2 instances
-        
+
         Migrated from: AWS_Stop_Idle_EC2_Instances.ipynb
-        
+
         Args:
             idle_instances: List of idle instances to stop
             dry_run: If True, only simulate the action
-            
+
         Returns:
             CostOptimizationResult with stopped instances and savings
         """
         print_header(f"Cost Optimizer - Stop Idle Instances ({'DRY RUN' if dry_run else 'LIVE'})")
-        
+
         stopped_instances = []
         total_savings = 0.0
         errors = []
-        
+
         with create_progress_bar() as progress:
-            task_id = progress.add_task(
-                "Processing idle instances...",
-                total=len(idle_instances)
-            )
-            
+            task_id = progress.add_task("Processing idle instances...", total=len(idle_instances))
+
             for instance in idle_instances:
                 try:
                     if dry_run:
                         # Simulate stop operation
                         stopped_instances.append(instance)
                         total_savings += instance.estimated_monthly_cost
-                        console.print(f"[yellow]DRY RUN: Would stop {instance.instance_id} "
-                                    f"(${instance.estimated_monthly_cost:.2f}/month savings)[/yellow]")
+                        console.print(
+                            f"[yellow]DRY RUN: Would stop {instance.instance_id} "
+                            f"(${instance.estimated_monthly_cost:.2f}/month savings)[/yellow]"
+                        )
                     else:
                         # Actually stop the instance
                         result = self._stop_single_instance(instance)
-                        if result['success']:
+                        if result["success"]:
                             stopped_instances.append(instance)
                             total_savings += instance.estimated_monthly_cost
-                            print_success(f"Stopped {instance.instance_id} - "
-                                        f"${instance.estimated_monthly_cost:.2f}/month saved")
+                            print_success(
+                                f"Stopped {instance.instance_id} - ${instance.estimated_monthly_cost:.2f}/month saved"
+                            )
                         else:
                             errors.append(f"{instance.instance_id}: {result['error']}")
                             print_error(f"Failed to stop {instance.instance_id}: {result['error']}")
-                    
+
                     progress.advance(task_id)
-                    
+
                 except Exception as e:
                     errors.append(f"{instance.instance_id}: {str(e)}")
                     print_error(f"Error processing {instance.instance_id}: {e}")
                     progress.advance(task_id)
-        
+
         # Create summary
         execution_summary = {
-            'total_instances_processed': len(idle_instances),
-            'successful_stops': len(stopped_instances),
-            'errors': errors,
-            'dry_run': dry_run,
-            'estimated_annual_savings': total_savings * 12
+            "total_instances_processed": len(idle_instances),
+            "successful_stops": len(stopped_instances),
+            "errors": errors,
+            "dry_run": dry_run,
+            "estimated_annual_savings": total_savings * 12,
         }
-        
+
         result = CostOptimizationResult(
             stopped_instances=stopped_instances,
             total_potential_savings=total_savings,
-            execution_summary=execution_summary
+            execution_summary=execution_summary,
         )
-        
+
         self._display_optimization_summary(result)
         return result
-    
+
     def _stop_single_instance(self, instance: IdleInstance) -> Dict[str, Any]:
         """Stop a single EC2 instance"""
-        
+
         try:
-            ec2_client = self.session.client('ec2', region_name=instance.region)
-            
+            ec2_client = self.session.client("ec2", region_name=instance.region)
+
             response = ec2_client.stop_instances(InstanceIds=[instance.instance_id])
-            
+
             # Extract state information
             instance_state = {}
-            for stopping_instance in response['StoppingInstances']:
-                instance_state[stopping_instance['InstanceId']] = stopping_instance['CurrentState']
-            
-            return {
-                'success': True,
-                'state_info': instance_state,
-                'instance_id': instance.instance_id
-            }
-            
+            for stopping_instance in response["StoppingInstances"]:
+                instance_state[stopping_instance["InstanceId"]] = stopping_instance["CurrentState"]
+
+            return {"success": True, "state_info": instance_state, "instance_id": instance.instance_id}
+
         except ClientError as e:
-            return {
-                'success': False,
-                'error': f"AWS API Error: {e}",
-                'instance_id': instance.instance_id
-            }
+            return {"success": False, "error": f"AWS API Error: {e}", "instance_id": instance.instance_id}
         except Exception as e:
-            return {
-                'success': False,
-                'error': f"Unexpected error: {e}",
-                'instance_id': instance.instance_id
-            }
-    
+            return {"success": False, "error": f"Unexpected error: {e}", "instance_id": instance.instance_id}
+
     def _get_all_regions(self) -> List[str]:
         """Get list of all AWS regions"""
         try:
-            ec2_client = self.session.client('ec2', region_name='us-east-1')
+            ec2_client = self.session.client("ec2", region_name="us-east-1")
             response = ec2_client.describe_regions()
-            return [region['RegionName'] for region in response['Regions']]
+            return [region["RegionName"] for region in response["Regions"]]
         except Exception:
             # Fallback to common regions
-            return [
-                'us-east-1', 'us-west-2', 'eu-west-1', 'eu-central-1',
-                'ap-southeast-1', 'ap-northeast-1'
-            ]
-    
+            return ["us-east-1", "us-west-2", "eu-west-1", "eu-central-1", "ap-southeast-1", "ap-northeast-1"]
+
     def _estimate_instance_monthly_cost(self, instance_type: str) -> float:
         """
         Estimate monthly cost for instance type
@@ -345,26 +323,26 @@ class AWSCostOptimizer:
         """
         # Simplified cost estimates (USD per month for common instance types)
         cost_map = {
-            't3.micro': 8.76,
-            't3.small': 17.52,
-            't3.medium': 35.04,
-            't3.large': 70.08,
-            't3.xlarge': 140.16,
-            't3.2xlarge': 280.32,
-            'm5.large': 87.60,
-            'm5.xlarge': 175.20,
-            'm5.2xlarge': 350.40,
-            'c5.large': 78.84,
-            'c5.xlarge': 157.68,
-            'r5.large': 116.8,
-            'r5.xlarge': 233.6,
+            "t3.micro": 8.76,
+            "t3.small": 17.52,
+            "t3.medium": 35.04,
+            "t3.large": 70.08,
+            "t3.xlarge": 140.16,
+            "t3.2xlarge": 280.32,
+            "m5.large": 87.60,
+            "m5.xlarge": 175.20,
+            "m5.2xlarge": 350.40,
+            "c5.large": 78.84,
+            "c5.xlarge": 157.68,
+            "r5.large": 116.8,
+            "r5.xlarge": 233.6,
         }
-        
+
         return cost_map.get(instance_type, 50.0)  # Default estimate
-    
+
     def _display_idle_instances_table(self, idle_instances: List[IdleInstance]):
         """Display idle instances in a formatted table"""
-        
+
         table = create_table(
             title="Idle EC2 Instances Found",
             columns=[
@@ -373,66 +351,61 @@ class AWSCostOptimizer:
                 {"header": "Type", "style": "green"},
                 {"header": "Est. Monthly Cost", "style": "red"},
                 {"header": "Tags", "style": "yellow"},
-            ]
+            ],
         )
-        
+
         for instance in idle_instances:
             # Format tags for display
-            tag_display = ', '.join([f"{k}:{v}" for k, v in list(instance.tags.items())[:2]])
+            tag_display = ", ".join([f"{k}:{v}" for k, v in list(instance.tags.items())[:2]])
             if len(instance.tags) > 2:
-                tag_display += f" (+{len(instance.tags)-2} more)"
-            
+                tag_display += f" (+{len(instance.tags) - 2} more)"
+
             table.add_row(
                 instance.instance_id,
                 instance.region,
                 instance.instance_type,
                 format_cost(instance.estimated_monthly_cost),
-                tag_display or "No tags"
+                tag_display or "No tags",
             )
-        
+
         console.print(table)
-    
+
     def find_low_usage_volumes(
-        self,
-        region: str = "",
-        threshold_days: int = 10
+        self, region: str = "", threshold_days: int = 10
     ) -> Tuple[bool, Optional[List[LowUsageVolume]]]:
         """
         Find EBS volumes with low usage based on CloudWatch metrics
-        
+
         Migrated from: AWS_Delete_EBS_Volumes_With_Low_Usage.ipynb
-        
+
         Args:
             region: AWS Region to scan (empty for all regions)
             threshold_days: Days to look back for usage metrics
-            
+
         Returns:
             Tuple (success, list_of_low_usage_volumes)
         """
         print_header("Cost Optimizer - Low Usage EBS Volume Detection", "latest version")
-        
+
         result = []
         regions_to_check = [region] if region else self._get_all_regions()
-        
+
         with create_progress_bar() as progress:
             task_id = progress.add_task(
-                f"Scanning {len(regions_to_check)} regions for low usage volumes...",
-                total=len(regions_to_check)
+                f"Scanning {len(regions_to_check)} regions for low usage volumes...", total=len(regions_to_check)
             )
-            
+
             for reg in regions_to_check:
                 try:
-                    low_usage_volumes = self._scan_region_for_low_usage_volumes(
-                        reg, threshold_days
-                    )
+                    low_usage_volumes = self._scan_region_for_low_usage_volumes(reg, threshold_days)
                     result.extend(low_usage_volumes)
                     progress.advance(task_id)
-                    
+
                 except Exception as e:
                     print_warning(f"Failed to scan region {reg}: {str(e)}")
                     progress.advance(task_id)
                     continue
-        
+
         if result:
             print_success(f"Found {len(result)} low usage volumes across {len(regions_to_check)} regions")
             self._display_low_usage_volumes_table(result)
@@ -440,205 +413,179 @@ class AWSCostOptimizer:
         else:
             print_success("No low usage volumes found")
             return (True, None)  # True = no results (unSkript convention)
-    
-    def _scan_region_for_low_usage_volumes(
-        self,
-        region: str,
-        threshold_days: int
-    ) -> List[LowUsageVolume]:
+
+    def _scan_region_for_low_usage_volumes(self, region: str, threshold_days: int) -> List[LowUsageVolume]:
         """Scan a specific region for low usage EBS volumes"""
-        
+
         result = []
-        
+
         try:
-            ec2_client = self.session.client('ec2', region_name=region)
-            cloudwatch_client = self.session.client('cloudwatch', region_name=region)
-            
+            ec2_client = self.session.client("ec2", region_name=region)
+            cloudwatch_client = self.session.client("cloudwatch", region_name=region)
+
             # Get all EBS volumes
-            paginator = ec2_client.get_paginator('describe_volumes')
-            
+            paginator = ec2_client.get_paginator("describe_volumes")
+
             now = datetime.datetime.utcnow()
             days_ago = now - datetime.timedelta(days=threshold_days)
-            
+
             for page in paginator.paginate():
-                for volume in page['Volumes']:
-                    volume_id = volume['VolumeId']
-                    
+                for volume in page["Volumes"]:
+                    volume_id = volume["VolumeId"]
+
                     # Get CloudWatch metrics for volume usage
                     try:
                         metrics_response = cloudwatch_client.get_metric_statistics(
-                            Namespace='AWS/EBS',
-                            MetricName='VolumeReadBytes',  # Changed from VolumeUsage to more standard metric
-                            Dimensions=[
-                                {
-                                    'Name': 'VolumeId',
-                                    'Value': volume_id
-                                }
-                            ],
+                            Namespace="AWS/EBS",
+                            MetricName="VolumeReadBytes",  # Changed from VolumeUsage to more standard metric
+                            Dimensions=[{"Name": "VolumeId", "Value": volume_id}],
                             StartTime=days_ago,
                             EndTime=now,
                             Period=86400,  # Daily periods
-                            Statistics=['Sum']
+                            Statistics=["Sum"],
                         )
-                        
+
                         # Calculate average usage
-                        total_bytes = sum(dp['Sum'] for dp in metrics_response['Datapoints'])
-                        avg_daily_bytes = total_bytes / max(len(metrics_response['Datapoints']), 1)
+                        total_bytes = sum(dp["Sum"] for dp in metrics_response["Datapoints"])
+                        avg_daily_bytes = total_bytes / max(len(metrics_response["Datapoints"]), 1)
                         avg_daily_gb = avg_daily_bytes / (1024**3)  # Convert to GB
-                        
+
                         # Consider volume as low usage if < 1GB daily average read
-                        if avg_daily_gb < 1.0 or not metrics_response['Datapoints']:
-                            
+                        if avg_daily_gb < 1.0 or not metrics_response["Datapoints"]:
                             # Extract tags
-                            tags = {tag['Key']: tag['Value'] for tag in volume.get('Tags', [])}
-                            
+                            tags = {tag["Key"]: tag["Value"] for tag in volume.get("Tags", [])}
+
                             low_usage_volume = LowUsageVolume(
                                 volume_id=volume_id,
                                 region=region,
-                                volume_type=volume.get('VolumeType', 'unknown'),
-                                size_gb=volume.get('Size', 0),
+                                volume_type=volume.get("VolumeType", "unknown"),
+                                size_gb=volume.get("Size", 0),
                                 avg_usage=avg_daily_gb,
-                                creation_date=volume.get('CreateTime', '').isoformat() if volume.get('CreateTime') else None,
-                                tags=tags
+                                creation_date=volume.get("CreateTime", "").isoformat()
+                                if volume.get("CreateTime")
+                                else None,
+                                tags=tags,
                             )
-                            
+
                             # Calculate estimated cost
                             low_usage_volume.estimated_monthly_cost = self._estimate_ebs_monthly_cost(
-                                volume.get('VolumeType', 'gp3'),
-                                volume.get('Size', 0)
+                                volume.get("VolumeType", "gp3"), volume.get("Size", 0)
                             )
-                            
+
                             result.append(low_usage_volume)
-                            
+
                     except ClientError as e:
                         # Skip volumes we can't get metrics for
-                        if 'Throttling' not in str(e):
+                        if "Throttling" not in str(e):
                             print_warning(f"Could not get metrics for volume {volume_id}: {e}")
                         continue
-                        
+
         except ClientError as e:
             print_warning(f"AWS API error in region {region}: {e}")
         except Exception as e:
             print_error(f"Unexpected error in region {region}: {e}")
-            
+
         return result
-    
+
     def delete_low_usage_volumes(
-        self,
-        low_usage_volumes: List[LowUsageVolume],
-        create_snapshots: bool = True,
-        dry_run: bool = True
+        self, low_usage_volumes: List[LowUsageVolume], create_snapshots: bool = True, dry_run: bool = True
     ) -> CostOptimizationResult:
         """
         Delete low usage EBS volumes (optionally creating snapshots first)
-        
+
         Migrated from: AWS_Delete_EBS_Volumes_With_Low_Usage.ipynb
-        
+
         Args:
             low_usage_volumes: List of volumes to delete
             create_snapshots: Create snapshots before deletion
             dry_run: If True, only simulate the action
-            
+
         Returns:
             CostOptimizationResult with deleted volumes and savings
         """
         print_header(f"Cost Optimizer - Delete Low Usage Volumes ({'DRY RUN' if dry_run else 'LIVE'})")
-        
+
         deleted_volumes = []
         total_savings = 0.0
         errors = []
-        
+
         with create_progress_bar() as progress:
-            task_id = progress.add_task(
-                "Processing low usage volumes...",
-                total=len(low_usage_volumes)
-            )
-            
+            task_id = progress.add_task("Processing low usage volumes...", total=len(low_usage_volumes))
+
             for volume in low_usage_volumes:
                 try:
                     if dry_run:
                         # Simulate deletion
                         deleted_volumes.append(volume)
                         total_savings += volume.estimated_monthly_cost
-                        console.print(f"[yellow]DRY RUN: Would delete {volume.volume_id} "
-                                    f"({volume.size_gb}GB {volume.volume_type}) - "
-                                    f"${volume.estimated_monthly_cost:.2f}/month savings[/yellow]")
+                        console.print(
+                            f"[yellow]DRY RUN: Would delete {volume.volume_id} "
+                            f"({volume.size_gb}GB {volume.volume_type}) - "
+                            f"${volume.estimated_monthly_cost:.2f}/month savings[/yellow]"
+                        )
                     else:
                         # Actually delete the volume
                         result = self._delete_single_volume(volume, create_snapshots)
-                        if result['success']:
+                        if result["success"]:
                             deleted_volumes.append(volume)
                             total_savings += volume.estimated_monthly_cost
-                            print_success(f"Deleted {volume.volume_id} - "
-                                        f"${volume.estimated_monthly_cost:.2f}/month saved")
+                            print_success(
+                                f"Deleted {volume.volume_id} - ${volume.estimated_monthly_cost:.2f}/month saved"
+                            )
                         else:
                             errors.append(f"{volume.volume_id}: {result['error']}")
                             print_error(f"Failed to delete {volume.volume_id}: {result['error']}")
-                    
+
                     progress.advance(task_id)
-                    
+
                 except Exception as e:
                     errors.append(f"{volume.volume_id}: {str(e)}")
                     print_error(f"Error processing {volume.volume_id}: {e}")
                     progress.advance(task_id)
-        
+
         # Create summary
         execution_summary = {
-            'total_volumes_processed': len(low_usage_volumes),
-            'successful_deletions': len(deleted_volumes),
-            'errors': errors,
-            'dry_run': dry_run,
-            'snapshots_created': create_snapshots,
-            'estimated_annual_savings': total_savings * 12
+            "total_volumes_processed": len(low_usage_volumes),
+            "successful_deletions": len(deleted_volumes),
+            "errors": errors,
+            "dry_run": dry_run,
+            "snapshots_created": create_snapshots,
+            "estimated_annual_savings": total_savings * 12,
         }
-        
+
         result = CostOptimizationResult(
-            deleted_volumes=deleted_volumes,
-            total_potential_savings=total_savings,
-            execution_summary=execution_summary
+            deleted_volumes=deleted_volumes, total_potential_savings=total_savings, execution_summary=execution_summary
         )
-        
+
         self._display_volume_optimization_summary(result)
         return result
-    
+
     def _delete_single_volume(self, volume: LowUsageVolume, create_snapshot: bool = True) -> Dict[str, Any]:
         """Delete a single EBS volume (with optional snapshot)"""
-        
+
         try:
-            ec2_client = self.session.client('ec2', region_name=volume.region)
-            
+            ec2_client = self.session.client("ec2", region_name=volume.region)
+
             snapshot_id = None
             if create_snapshot:
                 # Create snapshot first
                 snapshot_response = ec2_client.create_snapshot(
                     VolumeId=volume.volume_id,
-                    Description=f"Automated backup before deleting low usage volume {volume.volume_id}"
+                    Description=f"Automated backup before deleting low usage volume {volume.volume_id}",
                 )
-                snapshot_id = snapshot_response['SnapshotId']
+                snapshot_id = snapshot_response["SnapshotId"]
                 print_success(f"Created snapshot {snapshot_id} for volume {volume.volume_id}")
-            
+
             # Delete the volume
             ec2_client.delete_volume(VolumeId=volume.volume_id)
-            
-            return {
-                'success': True,
-                'snapshot_id': snapshot_id,
-                'volume_id': volume.volume_id
-            }
-            
+
+            return {"success": True, "snapshot_id": snapshot_id, "volume_id": volume.volume_id}
+
         except ClientError as e:
-            return {
-                'success': False,
-                'error': f"AWS API Error: {e}",
-                'volume_id': volume.volume_id
-            }
+            return {"success": False, "error": f"AWS API Error: {e}", "volume_id": volume.volume_id}
         except Exception as e:
-            return {
-                'success': False,
-                'error': f"Unexpected error: {e}",
-                'volume_id': volume.volume_id
-            }
-    
+            return {"success": False, "error": f"Unexpected error: {e}", "volume_id": volume.volume_id}
+
     def _estimate_ebs_monthly_cost(self, volume_type: str, size_gb: int) -> float:
         """
         Estimate monthly cost for EBS volume
@@ -646,21 +593,21 @@ class AWSCostOptimizer:
         """
         # Simplified cost estimates (USD per GB per month)
         cost_per_gb = {
-            'gp3': 0.08,
-            'gp2': 0.10,
-            'io1': 0.125,
-            'io2': 0.125,
-            'st1': 0.045,
-            'sc1': 0.025,
-            'standard': 0.05
+            "gp3": 0.08,
+            "gp2": 0.10,
+            "io1": 0.125,
+            "io2": 0.125,
+            "st1": 0.045,
+            "sc1": 0.025,
+            "standard": 0.05,
         }
-        
+
         rate = cost_per_gb.get(volume_type, 0.08)  # Default to gp3
         return size_gb * rate
-    
+
     def _display_low_usage_volumes_table(self, low_usage_volumes: List[LowUsageVolume]):
         """Display low usage volumes in a formatted table"""
-        
+
         table = create_table(
             title="Low Usage EBS Volumes Found",
             columns=[
@@ -670,99 +617,91 @@ class AWSCostOptimizer:
                 {"header": "Size (GB)", "style": "yellow"},
                 {"header": "Est. Monthly Cost", "style": "red"},
                 {"header": "Tags", "style": "magenta"},
-            ]
+            ],
         )
-        
+
         for volume in low_usage_volumes:
             # Format tags for display
-            tag_display = ', '.join([f"{k}:{v}" for k, v in list(volume.tags.items())[:2]])
+            tag_display = ", ".join([f"{k}:{v}" for k, v in list(volume.tags.items())[:2]])
             if len(volume.tags) > 2:
-                tag_display += f" (+{len(volume.tags)-2} more)"
-            
+                tag_display += f" (+{len(volume.tags) - 2} more)"
+
             table.add_row(
                 volume.volume_id,
                 volume.region,
                 volume.volume_type,
                 str(volume.size_gb),
                 format_cost(volume.estimated_monthly_cost),
-                tag_display or "No tags"
+                tag_display or "No tags",
             )
-        
+
         console.print(table)
-    
+
     def _display_volume_optimization_summary(self, result: CostOptimizationResult):
         """Display volume optimization summary"""
-        
+
         summary = result.execution_summary
-        
+
         console.print()
         print_header("EBS Volume Optimization Summary")
-        
+
         # Create summary table
         summary_table = create_table(
             title="Volume Optimization Results",
-            columns=[
-                {"header": "Metric", "style": "cyan"},
-                {"header": "Value", "style": "green bold"}
-            ]
+            columns=[{"header": "Metric", "style": "cyan"}, {"header": "Value", "style": "green bold"}],
         )
-        
-        summary_table.add_row("Volumes Processed", str(summary['total_volumes_processed']))
-        summary_table.add_row("Successfully Deleted", str(summary['successful_deletions']))
-        summary_table.add_row("Errors", str(len(summary['errors'])))
-        summary_table.add_row("Snapshots Created", "Yes" if summary['snapshots_created'] else "No")
+
+        summary_table.add_row("Volumes Processed", str(summary["total_volumes_processed"]))
+        summary_table.add_row("Successfully Deleted", str(summary["successful_deletions"]))
+        summary_table.add_row("Errors", str(len(summary["errors"])))
+        summary_table.add_row("Snapshots Created", "Yes" if summary["snapshots_created"] else "No")
         summary_table.add_row("Monthly Savings", format_cost(result.total_potential_savings))
-        summary_table.add_row("Annual Savings", format_cost(summary['estimated_annual_savings']))
-        summary_table.add_row("Mode", "DRY RUN" if summary['dry_run'] else "LIVE EXECUTION")
-        
+        summary_table.add_row("Annual Savings", format_cost(summary["estimated_annual_savings"]))
+        summary_table.add_row("Mode", "DRY RUN" if summary["dry_run"] else "LIVE EXECUTION")
+
         console.print(summary_table)
-        
-        if summary['errors']:
+
+        if summary["errors"]:
             print_warning(f"Encountered {len(summary['errors'])} errors:")
-            for error in summary['errors']:
+            for error in summary["errors"]:
                 console.print(f"  [red]• {error}[/red]")
-    
+
     def find_unused_nat_gateways(
-        self,
-        region: str = "",
-        number_of_days: int = 7
+        self, region: str = "", number_of_days: int = 7
     ) -> Tuple[bool, Optional[List[UnusedNATGateway]]]:
         """
         Find unused NAT Gateways based on CloudWatch connection metrics
-        
+
         Migrated from: AWS_Delete_Unused_NAT_Gateways.ipynb
-        
+
         Args:
             region: AWS Region to scan (empty for all regions)
             number_of_days: Days to look back for usage metrics
-            
+
         Returns:
             Tuple (success, list_of_unused_nat_gateways)
         """
         print_header("Cost Optimizer - Unused NAT Gateway Detection", "latest version")
-        
+
         result = []
         regions_to_check = [region] if region else self._get_all_regions()
-        
+
         with create_progress_bar() as progress:
             task_id = progress.add_task(
-                f"Scanning {len(regions_to_check)} regions for unused NAT Gateways...",
-                total=len(regions_to_check)
+                f"Scanning {len(regions_to_check)} regions for unused NAT Gateways...", total=len(regions_to_check)
             )
-            
+
             for reg in regions_to_check:
                 try:
-                    unused_gateways = self._scan_region_for_unused_nat_gateways(
-                        reg, number_of_days
-                    )
+                    unused_gateways = self._scan_region_for_unused_nat_gateways(reg, number_of_days)
                     result.extend(unused_gateways)
                     progress.advance(task_id)
-                    
+
                 except Exception as e:
                     print_warning(f"Failed to scan region {reg}: {str(e)}")
                     progress.advance(task_id)
                     continue
-        
+
         if result:
             print_success(f"Found {len(result)} unused NAT Gateways across {len(regions_to_check)} regions")
             self._display_unused_nat_gateways_table(result)
@@ -770,205 +709,184 @@ class AWSCostOptimizer:
         else:
             print_success("No unused NAT Gateways found")
             return (True, None)  # True = no results (unSkript convention)
-    
-    def _scan_region_for_unused_nat_gateways(
-        self,
-        region: str,
-        number_of_days: int
-    ) -> List[UnusedNATGateway]:
+
+    def _scan_region_for_unused_nat_gateways(self, region: str, number_of_days: int) -> List[UnusedNATGateway]:
         """Scan a specific region for unused NAT Gateways"""
-        
+
         result = []
-        
+
         try:
-            ec2_client = self.session.client('ec2', region_name=region)
-            cloudwatch_client = self.session.client('cloudwatch', region_name=region)
-            
+            ec2_client = self.session.client("ec2", region_name=region)
+            cloudwatch_client = self.session.client("cloudwatch", region_name=region)
+
             # Get all NAT Gateways
             response = ec2_client.describe_nat_gateways()
-            
+
             end_time = datetime.datetime.utcnow()
             start_time = end_time - datetime.timedelta(days=number_of_days)
-            
-            for nat_gateway in response['NatGateways']:
-                if nat_gateway['State'] == 'deleted':
+
+            for nat_gateway in response["NatGateways"]:
+                if nat_gateway["State"] == "deleted":
                     continue
-                    
-                nat_gateway_id = nat_gateway['NatGatewayId']
-                
+
+                nat_gateway_id = nat_gateway["NatGatewayId"]
+
                 # Check if NAT Gateway is used based on connection metrics
-                if not self._is_nat_gateway_used(
-                    cloudwatch_client, nat_gateway, start_time, end_time, number_of_days
-                ):
+                if not self._is_nat_gateway_used(cloudwatch_client, nat_gateway, start_time, end_time, number_of_days):
                     # Extract tags
-                    tags = {tag['Key']: tag['Value'] for tag in nat_gateway.get('Tags', [])}
-                    
+                    tags = {tag["Key"]: tag["Value"] for tag in nat_gateway.get("Tags", [])}
+
                     unused_gateway = UnusedNATGateway(
                         nat_gateway_id=nat_gateway_id,
                         region=region,
-                        vpc_id=nat_gateway.get('VpcId', ''),
-                        state=nat_gateway.get('State', ''),
-                        creation_date=nat_gateway.get('CreateTime', '').isoformat() if nat_gateway.get('CreateTime') else None,
-                        tags=tags
+                        vpc_id=nat_gateway.get("VpcId", ""),
+                        state=nat_gateway.get("State", ""),
+                        creation_date=nat_gateway.get("CreateTime", "").isoformat()
+                        if nat_gateway.get("CreateTime")
+                        else None,
+                        tags=tags,
                     )
-                    
+
                     result.append(unused_gateway)
-                        
+
         except ClientError as e:
             print_warning(f"AWS API error in region {region}: {e}")
         except Exception as e:
             print_error(f"Unexpected error in region {region}: {e}")
-            
+
         return result
-    
+
     def _is_nat_gateway_used(
         self,
         cloudwatch_client,
         nat_gateway: Dict[str, Any],
         start_time: datetime.datetime,
         end_time: datetime.datetime,
-        number_of_days: int
+        number_of_days: int,
     ) -> bool:
         """Check if NAT Gateway is used based on connection metrics"""
-        
+
         try:
-            if nat_gateway['State'] != 'available':
+            if nat_gateway["State"] != "available":
                 return True  # Consider non-available gateways as "used"
-            
+
             # Get ActiveConnectionCount metrics
             metrics_response = cloudwatch_client.get_metric_statistics(
-                Namespace='AWS/NATGateway',
-                MetricName='ActiveConnectionCount',
+                Namespace="AWS/NATGateway",
+                MetricName="ActiveConnectionCount",
                 Dimensions=[
-                    {
-                        'Name': 'NatGatewayId',
-                        'Value': nat_gateway['NatGatewayId']
-                    },
+                    {"Name": "NatGatewayId", "Value": nat_gateway["NatGatewayId"]},
                 ],
                 StartTime=start_time,
                 EndTime=end_time,
                 Period=86400 * number_of_days,  # Daily periods
-                Statistics=['Sum']
+                Statistics=["Sum"],
             )
-            
-            datapoints = metrics_response.get('Datapoints', [])
-            
+
+            datapoints = metrics_response.get("Datapoints", [])
+
             if not datapoints:
                 return False  # No metrics = unused
-                
+
             # Check if there are any active connections
-            total_connections = sum(dp['Sum'] for dp in datapoints)
+            total_connections = sum(dp["Sum"] for dp in datapoints)
             return total_connections > 0
-            
+
         except Exception as e:
             print_warning(f"Could not get metrics for NAT Gateway {nat_gateway['NatGatewayId']}: {e}")
             return True  # Assume used if we can't get metrics
-    
+
     def delete_unused_nat_gateways(
-        self,
-        unused_nat_gateways: List[UnusedNATGateway],
-        dry_run: bool = True
+        self, unused_nat_gateways: List[UnusedNATGateway], dry_run: bool = True
     ) -> CostOptimizationResult:
         """
         Delete unused NAT Gateways
-        
+
         Migrated from: AWS_Delete_Unused_NAT_Gateways.ipynb
-        
+
         Args:
             unused_nat_gateways: List of NAT Gateways to delete
             dry_run: If True, only simulate the action
-            
+
         Returns:
             CostOptimizationResult with deleted NAT Gateways and savings
         """
         print_header(f"Cost Optimizer - Delete Unused NAT Gateways ({'DRY RUN' if dry_run else 'LIVE'})")
-        
+
         deleted_gateways = []
         total_savings = 0.0
         errors = []
-        
+
         with create_progress_bar() as progress:
-            task_id = progress.add_task(
-                "Processing unused NAT Gateways...",
-                total=len(unused_nat_gateways)
-            )
-            
+            task_id = progress.add_task("Processing unused NAT Gateways...", total=len(unused_nat_gateways))
+
             for gateway in unused_nat_gateways:
                 try:
                     if dry_run:
                         # Simulate deletion
                         deleted_gateways.append(gateway)
                         total_savings += gateway.estimated_monthly_cost
-                        console.print(f"[yellow]DRY RUN: Would delete {gateway.nat_gateway_id} "
-                                    f"in VPC {gateway.vpc_id} - "
-                                    f"${gateway.estimated_monthly_cost:.2f}/month savings[/yellow]")
+                        console.print(
+                            f"[yellow]DRY RUN: Would delete {gateway.nat_gateway_id} "
+                            f"in VPC {gateway.vpc_id} - "
+                            f"${gateway.estimated_monthly_cost:.2f}/month savings[/yellow]"
+                        )
                     else:
                         # Actually delete the NAT Gateway
                         result = self._delete_single_nat_gateway(gateway)
-                        if result['success']:
+                        if result["success"]:
                             deleted_gateways.append(gateway)
                             total_savings += gateway.estimated_monthly_cost
-                            print_success(f"Deleted {gateway.nat_gateway_id} - "
-                                        f"${gateway.estimated_monthly_cost:.2f}/month saved")
+                            print_success(
+                                f"Deleted {gateway.nat_gateway_id} - ${gateway.estimated_monthly_cost:.2f}/month saved"
+                            )
                         else:
                             errors.append(f"{gateway.nat_gateway_id}: {result['error']}")
                             print_error(f"Failed to delete {gateway.nat_gateway_id}: {result['error']}")
-                    
+
                     progress.advance(task_id)
-                    
+
                 except Exception as e:
                     errors.append(f"{gateway.nat_gateway_id}: {str(e)}")
                     print_error(f"Error processing {gateway.nat_gateway_id}: {e}")
                     progress.advance(task_id)
-        
+
         # Create summary
         execution_summary = {
-            'total_nat_gateways_processed': len(unused_nat_gateways),
-            'successful_deletions': len(deleted_gateways),
-            'errors': errors,
-            'dry_run': dry_run,
-            'estimated_annual_savings': total_savings * 12
+            "total_nat_gateways_processed": len(unused_nat_gateways),
+            "successful_deletions": len(deleted_gateways),
+            "errors": errors,
+            "dry_run": dry_run,
+            "estimated_annual_savings": total_savings * 12,
         }
-        
+
         result = CostOptimizationResult(
             deleted_nat_gateways=deleted_gateways,
             total_potential_savings=total_savings,
-            execution_summary=execution_summary
+            execution_summary=execution_summary,
         )
-        
+
         self._display_nat_gateway_optimization_summary(result)
         return result
-    
+
     def _delete_single_nat_gateway(self, gateway: UnusedNATGateway) -> Dict[str, Any]:
         """Delete a single NAT Gateway"""
-        
+
         try:
-            ec2_client = self.session.client('ec2', region_name=gateway.region)
-            
+            ec2_client = self.session.client("ec2", region_name=gateway.region)
+
             response = ec2_client.delete_nat_gateway(NatGatewayId=gateway.nat_gateway_id)
-            
-            return {
-                'success': True,
-                'response': response,
-                'nat_gateway_id': gateway.nat_gateway_id
-            }
-            
+
+            return {"success": True, "response": response, "nat_gateway_id": gateway.nat_gateway_id}
+
         except ClientError as e:
-            return {
-                'success': False,
-                'error': f"AWS API Error: {e}",
-                'nat_gateway_id': gateway.nat_gateway_id
-            }
+            return {"success": False, "error": f"AWS API Error: {e}", "nat_gateway_id": gateway.nat_gateway_id}
         except Exception as e:
-            return {
-                'success': False,
-                'error': f"Unexpected error: {e}",
-                'nat_gateway_id': gateway.nat_gateway_id
-            }
-    
+            return {"success": False, "error": f"Unexpected error: {e}", "nat_gateway_id": gateway.nat_gateway_id}
+
     def _display_unused_nat_gateways_table(self, unused_gateways: List[UnusedNATGateway]):
         """Display unused NAT Gateways in a formatted table"""
-        
+
         table = create_table(
             title="Unused NAT Gateways Found",
             columns=[
@@ -978,86 +896,80 @@ class AWSCostOptimizer:
                 {"header": "State", "style": "yellow"},
                 {"header": "Est. Monthly Cost", "style": "red"},
                 {"header": "Tags", "style": "magenta"},
-            ]
+            ],
         )
-        
+
         for gateway in unused_gateways:
             # Format tags for display
-            tag_display = ', '.join([f"{k}:{v}" for k, v in list(gateway.tags.items())[:2]])
+            tag_display = ", ".join([f"{k}:{v}" for k, v in list(gateway.tags.items())[:2]])
             if len(gateway.tags) > 2:
-                tag_display += f" (+{len(gateway.tags)-2} more)"
-            
+                tag_display += f" (+{len(gateway.tags) - 2} more)"
+
             table.add_row(
                 gateway.nat_gateway_id,
                 gateway.region,
                 gateway.vpc_id,
                 gateway.state,
                 format_cost(gateway.estimated_monthly_cost),
-                tag_display or "No tags"
+                tag_display or "No tags",
             )
-        
+
         console.print(table)
-    
+
     def _display_nat_gateway_optimization_summary(self, result: CostOptimizationResult):
         """Display NAT Gateway optimization summary"""
-        
+
         summary = result.execution_summary
-        
+
         console.print()
         print_header("NAT Gateway Optimization Summary")
-        
+
         # Create summary table
         summary_table = create_table(
             title="NAT Gateway Optimization Results",
-            columns=[
-                {"header": "Metric", "style": "cyan"},
-                {"header": "Value", "style": "green bold"}
-            ]
+            columns=[{"header": "Metric", "style": "cyan"}, {"header": "Value", "style": "green bold"}],
         )
-        
-        summary_table.add_row("NAT Gateways Processed", str(summary['total_nat_gateways_processed']))
-        summary_table.add_row("Successfully Deleted", str(summary['successful_deletions']))
-        summary_table.add_row("Errors", str(len(summary['errors'])))
+
+        summary_table.add_row("NAT Gateways Processed", str(summary["total_nat_gateways_processed"]))
+        summary_table.add_row("Successfully Deleted", str(summary["successful_deletions"]))
+        summary_table.add_row("Errors", str(len(summary["errors"])))
         summary_table.add_row("Monthly Savings", format_cost(result.total_potential_savings))
-        summary_table.add_row("Annual Savings", format_cost(summary['estimated_annual_savings']))
-        summary_table.add_row("Mode", "DRY RUN" if summary['dry_run'] else "LIVE EXECUTION")
-        
+        summary_table.add_row("Annual Savings", format_cost(summary["estimated_annual_savings"]))
+        summary_table.add_row("Mode", "DRY RUN" if summary["dry_run"] else "LIVE EXECUTION")
+
         console.print(summary_table)
-        
-        if summary['errors']:
+
+        if summary["errors"]:
             print_warning(f"Encountered {len(summary['errors'])} errors:")
-            for error in summary['errors']:
+            for error in summary["errors"]:
                 console.print(f"  [red]• {error}[/red]")
-    
+
     def _display_optimization_summary(self, result: CostOptimizationResult):
         """Display cost optimization summary"""
-        
+
         summary = result.execution_summary
-        
+
         console.print()
         print_header("Cost Optimization Summary")
-        
+
         # Create summary table
         summary_table = create_table(
             title="Optimization Results",
-            columns=[
-                {"header": "Metric", "style": "cyan"},
-                {"header": "Value", "style": "green bold"}
-            ]
+            columns=[{"header": "Metric", "style": "cyan"}, {"header": "Value", "style": "green bold"}],
         )
-        
-        summary_table.add_row("Instances Processed", str(summary['total_instances_processed']))
-        summary_table.add_row("Successfully Stopped", str(summary['successful_stops']))
-        summary_table.add_row("Errors", str(len(summary['errors'])))
+
+        summary_table.add_row("Instances Processed", str(summary["total_instances_processed"]))
+        summary_table.add_row("Successfully Stopped", str(summary["successful_stops"]))
+        summary_table.add_row("Errors", str(len(summary["errors"])))
         summary_table.add_row("Monthly Savings", format_cost(result.total_potential_savings))
-        summary_table.add_row("Annual Savings", format_cost(summary['estimated_annual_savings']))
-        summary_table.add_row("Mode", "DRY RUN" if summary['dry_run'] else "LIVE EXECUTION")
-        
+        summary_table.add_row("Annual Savings", format_cost(summary["estimated_annual_savings"]))
+        summary_table.add_row("Mode", "DRY RUN" if summary["dry_run"] else "LIVE EXECUTION")
+
         console.print(summary_table)
-        
-        if summary['errors']:
+
+        if summary["errors"]:
             print_warning(f"Encountered {len(summary['errors'])} errors:")
-            for error in summary['errors']:
+            for error in summary["errors"]:
                 console.print(f"  [red]• {error}[/red]")
 
 
@@ -1068,16 +980,16 @@ def find_and_stop_idle_instances(
     idle_cpu_threshold: int = 5,
     idle_duration: int = 6,
     instance_ids: Optional[List[str]] = None,
-    dry_run: bool = True
+    dry_run: bool = True,
 ) -> Dict[str, Any]:
     """
     Main function for cost optimization - find and stop idle EC2 instances
-    
+
     This function replicates the complete unSkript notebook workflow
     """
-    
+
     optimizer = AWSCostOptimizer(profile=profile)
-    
+
     # Step 1: Find idle instances (or use provided instance IDs)
     if instance_ids:
         print_warning("Using provided instance IDs - skipping idle detection")
@@ -1087,41 +999,31 @@ def find_and_stop_idle_instances(
             idle_instance = IdleInstance(
                 instance_id=instance_id,
                 region=region,
-                estimated_monthly_cost=50.0  # Default estimate
+                estimated_monthly_cost=50.0,  # Default estimate
             )
             idle_instances.append(idle_instance)
         success = False
         found_instances = idle_instances
     else:
         success, found_instances = optimizer.find_idle_instances(
-            region=region,
-            idle_cpu_threshold=idle_cpu_threshold,
-            idle_duration=idle_duration
+            region=region, idle_cpu_threshold=idle_cpu_threshold, idle_duration=idle_duration
         )
-    
+
     if success or not found_instances:  # No idle instances found
         print_success("No idle instances to process")
-        return {
-            'idle_instances_found': 0,
-            'instances_stopped': 0,
-            'potential_savings': 0.0,
-            'status': 'completed'
-        }
-    
+        return {"idle_instances_found": 0, "instances_stopped": 0, "potential_savings": 0.0, "status": "completed"}
+
     # Step 2: Stop idle instances
-    optimization_result = optimizer.stop_idle_instances(
-        idle_instances=found_instances,
-        dry_run=dry_run
-    )
-    
+    optimization_result = optimizer.stop_idle_instances(idle_instances=found_instances, dry_run=dry_run)
+
     return {
-        'idle_instances_found': len(found_instances),
-        'instances_stopped': len(optimization_result.stopped_instances),
-        'potential_monthly_savings': optimization_result.total_potential_savings,
-        'potential_annual_savings': optimization_result.execution_summary['estimated_annual_savings'],
-        'dry_run': dry_run,
-        'status': 'completed',
-        'details': optimization_result.execution_summary
+        "idle_instances_found": len(found_instances),
+        "instances_stopped": len(optimization_result.stopped_instances),
+        "potential_monthly_savings": optimization_result.total_potential_savings,
+        "potential_annual_savings": optimization_result.execution_summary["estimated_annual_savings"],
+        "dry_run": dry_run,
+        "status": "completed",
+        "details": optimization_result.execution_summary,
     }
 
 
@@ -1132,16 +1034,16 @@ def find_and_delete_low_usage_volumes(
     threshold_days: int = 10,
     volume_ids: Optional[List[str]] = None,
     create_snapshots: bool = True,
-    dry_run: bool = True
+    dry_run: bool = True,
 ) -> Dict[str, Any]:
     """
     Main function for EBS cost optimization - find and delete low usage volumes
-    
+
     Migrated from: AWS_Delete_EBS_Volumes_With_Low_Usage.ipynb
     """
-    
+
     optimizer = AWSCostOptimizer(profile=profile)
-    
+
     # Step 1: Find low usage volumes (or use provided volume IDs)
     if volume_ids:
         print_warning("Using provided volume IDs - skipping usage detection")
@@ -1151,42 +1053,32 @@ def find_and_delete_low_usage_volumes(
             low_usage_volume = LowUsageVolume(
                 volume_id=volume_id,
                 region=region,
-                estimated_monthly_cost=5.0  # Default estimate
+                estimated_monthly_cost=5.0,  # Default estimate
             )
             low_usage_volumes.append(low_usage_volume)
         success = False
         found_volumes = low_usage_volumes
     else:
-        success, found_volumes = optimizer.find_low_usage_volumes(
-            region=region,
-            threshold_days=threshold_days
-        )
-    
+        success, found_volumes = optimizer.find_low_usage_volumes(region=region, threshold_days=threshold_days)
+
     if success or not found_volumes:  # No low usage volumes found
         print_success("No low usage volumes to process")
-        return {
-            'low_usage_volumes_found': 0,
-            'volumes_deleted': 0,
-            'potential_savings': 0.0,
-            'status': 'completed'
-        }
-    
+        return {"low_usage_volumes_found": 0, "volumes_deleted": 0, "potential_savings": 0.0, "status": "completed"}
+
     # Step 2: Delete low usage volumes
     optimization_result = optimizer.delete_low_usage_volumes(
-        low_usage_volumes=found_volumes,
-        create_snapshots=create_snapshots,
-        dry_run=dry_run
+        low_usage_volumes=found_volumes, create_snapshots=create_snapshots, dry_run=dry_run
     )
-    
+
     return {
-        'low_usage_volumes_found': len(found_volumes),
-        'volumes_deleted': len(optimization_result.deleted_volumes),
-        'potential_monthly_savings': optimization_result.total_potential_savings,
-        'potential_annual_savings': optimization_result.execution_summary['estimated_annual_savings'],
-        'snapshots_created': create_snapshots,
-        'dry_run': dry_run,
-        'status': 'completed',
-        'details': optimization_result.execution_summary
+        "low_usage_volumes_found": len(found_volumes),
+        "volumes_deleted": len(optimization_result.deleted_volumes),
+        "potential_monthly_savings": optimization_result.total_potential_savings,
+        "potential_annual_savings": optimization_result.execution_summary["estimated_annual_savings"],
+        "snapshots_created": create_snapshots,
+        "dry_run": dry_run,
+        "status": "completed",
+        "details": optimization_result.execution_summary,
     }
 
 
@@ -1196,22 +1088,22 @@ def comprehensive_cost_optimization(
     idle_cpu_threshold: int = 5,
     idle_duration: int = 6,
     volume_threshold_days: int = 10,
-    dry_run: bool = True
+    dry_run: bool = True,
 ) -> Dict[str, Any]:
     """
     Comprehensive cost optimization combining EC2 and EBS optimizations
-    
+
     This combines multiple unSkript notebooks:
-    - AWS_Stop_Idle_EC2_Instances.ipynb 
+    - AWS_Stop_Idle_EC2_Instances.ipynb
     - AWS_Delete_EBS_Volumes_With_Low_Usage.ipynb
     """
-    
+
     print_header("Comprehensive AWS Cost Optimization", "latest version")
-    
+
     total_monthly_savings = 0.0
     total_annual_savings = 0.0
     results = {}
-    
+
     # Step 1: EC2 Instance Optimization
     try:
         print_header("Phase 1: EC2 Instance Optimization")
@@ -1220,123 +1112,97 @@ def comprehensive_cost_optimization(
             region=region,
             idle_cpu_threshold=idle_cpu_threshold,
             idle_duration=idle_duration,
-            dry_run=dry_run
+            dry_run=dry_run,
         )
-        results['ec2_optimization'] = ec2_result
-        total_monthly_savings += ec2_result.get('potential_monthly_savings', 0.0)
-        total_annual_savings += ec2_result.get('potential_annual_savings', 0.0)
-        
+        results["ec2_optimization"] = ec2_result
+        total_monthly_savings += ec2_result.get("potential_monthly_savings", 0.0)
+        total_annual_savings += ec2_result.get("potential_annual_savings", 0.0)
+
     except Exception as e:
         print_error(f"EC2 optimization failed: {e}")
-        results['ec2_optimization'] = {'error': str(e)}
-    
-    # Step 2: EBS Volume Optimization  
+        results["ec2_optimization"] = {"error": str(e)}
+
+    # Step 2: EBS Volume Optimization
     try:
         print_header("Phase 2: EBS Volume Optimization")
         ebs_result = find_and_delete_low_usage_volumes(
-            profile=profile,
-            region=region,
-            threshold_days=volume_threshold_days,
-            create_snapshots=True,
-            dry_run=dry_run
+            profile=profile, region=region, threshold_days=volume_threshold_days, create_snapshots=True, dry_run=dry_run
         )
-        results['ebs_optimization'] = ebs_result
-        total_monthly_savings += ebs_result.get('potential_monthly_savings', 0.0)
-        total_annual_savings += ebs_result.get('potential_annual_savings', 0.0)
-        
+        results["ebs_optimization"] = ebs_result
+        total_monthly_savings += ebs_result.get("potential_monthly_savings", 0.0)
+        total_annual_savings += ebs_result.get("potential_annual_savings", 0.0)
+
     except Exception as e:
         print_error(f"EBS optimization failed: {e}")
-        results['ebs_optimization'] = {'error': str(e)}
-    
+        results["ebs_optimization"] = {"error": str(e)}
+
     # Summary
     print_header("Comprehensive Cost Optimization Summary")
-    
+
     summary_table = create_table(
         title="Total Cost Optimization Impact",
         columns=[
             {"header": "Resource Type", "style": "cyan"},
-            {"header": "Items Found", "style": "yellow"},  
+            {"header": "Items Found", "style": "yellow"},
             {"header": "Items Processed", "style": "green"},
             {"header": "Monthly Savings", "style": "red bold"},
-        ]
+        ],
     )
-    
+
     # EC2 Summary
-    ec2_found = results.get('ec2_optimization', {}).get('idle_instances_found', 0)
-    ec2_stopped = results.get('ec2_optimization', {}).get('instances_stopped', 0)
-    ec2_savings = results.get('ec2_optimization', {}).get('potential_monthly_savings', 0.0)
-    
-    summary_table.add_row(
-        "EC2 Instances", 
-        str(ec2_found), 
-        str(ec2_stopped),
-        format_cost(ec2_savings)
-    )
-    
+    ec2_found = results.get("ec2_optimization", {}).get("idle_instances_found", 0)
+    ec2_stopped = results.get("ec2_optimization", {}).get("instances_stopped", 0)
+    ec2_savings = results.get("ec2_optimization", {}).get("potential_monthly_savings", 0.0)
+
+    summary_table.add_row("EC2 Instances", str(ec2_found), str(ec2_stopped), format_cost(ec2_savings))
+
     # EBS Summary
-    ebs_found = results.get('ebs_optimization', {}).get('low_usage_volumes_found', 0)
-    ebs_deleted = results.get('ebs_optimization', {}).get('volumes_deleted', 0)
-    ebs_savings = results.get('ebs_optimization', {}).get('potential_monthly_savings', 0.0)
-    
-    summary_table.add_row(
-        "EBS Volumes",
-        str(ebs_found),
-        str(ebs_deleted), 
-        format_cost(ebs_savings)
-    )
-    
+    ebs_found = results.get("ebs_optimization", {}).get("low_usage_volumes_found", 0)
+    ebs_deleted = results.get("ebs_optimization", {}).get("volumes_deleted", 0)
+    ebs_savings = results.get("ebs_optimization", {}).get("potential_monthly_savings", 0.0)
+
+    summary_table.add_row("EBS Volumes", str(ebs_found), str(ebs_deleted), format_cost(ebs_savings))
+
     # Total
     summary_table.add_row(
         "[bold]TOTAL[/bold]",
         "[bold]" + str(ec2_found + ebs_found) + "[/bold]",
         "[bold]" + str(ec2_stopped + ebs_deleted) + "[/bold]",
-        "[bold]" + format_cost(total_monthly_savings) + "[/bold]"
+        "[bold]" + format_cost(total_monthly_savings) + "[/bold]",
     )
-    
+
     console.print(summary_table)
-    
+
     print_success(f"Total Annual Savings Potential: {format_cost(total_annual_savings)}")
-    
+
     if dry_run:
         print_warning("This was a DRY RUN. No actual changes were made.")
-    
+
     return {
-        'total_monthly_savings': total_monthly_savings,
-        'total_annual_savings': total_annual_savings,
-        'ec2_optimization': results.get('ec2_optimization', {}),
-        'ebs_optimization': results.get('ebs_optimization', {}),
-        'dry_run': dry_run,
-        'status': 'completed'
+        "total_monthly_savings": total_monthly_savings,
+        "total_annual_savings": total_annual_savings,
+        "ec2_optimization": results.get("ec2_optimization", {}),
+        "ebs_optimization": results.get("ebs_optimization", {}),
+        "dry_run": dry_run,
+        "status": "completed",
     }
 
 
 if __name__ == "__main__":
     # Direct execution for testing
     print("Testing Cost Optimization Module...")
-    
+
     # Test 1: EC2 Instance Optimization
     print("\n=== Testing EC2 Optimization ===")
-    ec2_result = find_and_stop_idle_instances(
-        region="us-east-1",
-        idle_cpu_threshold=10,
-        idle_duration=24,
-        dry_run=True
-    )
+    ec2_result = find_and_stop_idle_instances(region="us-east-1", idle_cpu_threshold=10, idle_duration=24, dry_run=True)
     print(f"EC2 Result: {ec2_result}")
-    
-    # Test 2: EBS Volume Optimization  
+
+    # Test 2: EBS Volume Optimization
     print("\n=== Testing EBS Optimization ===")
-    ebs_result = find_and_delete_low_usage_volumes(
-        region="us-east-1",
-        threshold_days=30,
-        dry_run=True
-    )
+    ebs_result = find_and_delete_low_usage_volumes(region="us-east-1", threshold_days=30, dry_run=True)
     print(f"EBS Result: {ebs_result}")
-    
+
     # Test 3: Comprehensive Optimization
     print("\n=== Testing Comprehensive Optimization ===")
-    comprehensive_result = comprehensive_cost_optimization(
-        region="us-east-1",
-        dry_run=True
-    )
-    print(f"Comprehensive Result: {comprehensive_result}")
+    comprehensive_result = comprehensive_cost_optimization(region="us-east-1", dry_run=True)
+    print(f"Comprehensive Result: {comprehensive_result}")