runbooks 0.7.7__py3-none-any.whl → 0.7.9__py3-none-any.whl

runbooks/finops/optimizer.py

@@ -4,16 +4,18 @@ Sprint 1-3: Achieve 40% cost reduction ($1.4M annually)
 """
 
 import json
-import boto3
-from datetime import datetime, timedelta
-from typing import Dict, List, Any, Optional
-from dataclasses import dataclass
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional
+
+import boto3
 
 
 @dataclass
 class CostSavingsOpportunity:
     """Data class for cost savings opportunity."""
+
     resource_type: str
     resource_id: str
     account_id: str
@@ -30,15 +32,15 @@ class CostOptimizer:
     Advanced cost optimization engine for enterprise AWS organizations.
     Identifies 25-50% cost savings opportunities across all services.
     """
-    
-    def __init__(self, profile: str = None, target_savings_percent: float = 40.0, max_accounts: int = 60):
+
+    def __init__(self, profile: str = None, target_savings_percent: float = 40.0, max_accounts: int = None):
         """
         Initialize cost optimizer for enterprise-scale analysis.
-        
+
         Args:
             profile: AWS profile for authentication
             target_savings_percent: Target savings percentage (default: 40%)
-            max_accounts: Maximum accounts to analyze (default: 60 for full org)
+            max_accounts: Maximum accounts to analyze (None = analyze all discovered accounts)
         """
         self.profile = profile
         self.target_savings_percent = target_savings_percent
@@ -47,351 +49,348 @@ class CostOptimizer:
         self.opportunities = []
         self.analysis_results = {}
         self.enhanced_services = [
-            'ec2', 's3', 'rds', 'lambda', 'dynamodb', 'cloudwatch',
-            'vpc', 'elb', 'ebs', 'eip', 'nat_gateway', 'cloudtrail'
+            "ec2",
+            "s3",
+            "rds",
+            "lambda",
+            "dynamodb",
+            "cloudwatch",
+            "vpc",
+            "elb",
+            "ebs",
+            "eip",
+            "nat_gateway",
+            "cloudtrail",
         ]
-    
+
     def identify_all_waste(self, accounts: List[str] = None) -> Dict[str, List[CostSavingsOpportunity]]:
         """
         Enhanced waste identification across all accounts with broader coverage.
-        
+
         Returns:
             Dictionary of waste patterns with savings opportunities
         """
         if not accounts:
-            accounts = self._get_all_accounts()[:self.max_accounts]
-            
+            accounts = self._get_all_accounts()[: self.max_accounts]
+
         print(f"🔍 Analyzing {len(accounts)} accounts for cost optimization opportunities...")
-        
+
         waste_patterns = {
-            'idle_resources': self.find_idle_resources(accounts),
-            'oversized_instances': self.analyze_rightsizing_opportunities(accounts),
-            'unattached_storage': self.find_orphaned_ebs_volumes(accounts),
-            'old_snapshots': self.find_old_snapshots(accounts),
-            'unused_elastic_ips': self.find_unused_elastic_ips(accounts),
-            'underutilized_rds': self.find_underutilized_rds(accounts),
-            'lambda_over_provisioned': self.find_lambda_waste(accounts),
-            'unused_load_balancers': self.find_unused_load_balancers(accounts),
-            'storage_class_optimization': self.analyze_s3_storage_class(accounts),
-            'cloudwatch_logs_retention': self.analyze_log_retention(accounts),
+            "idle_resources": self.find_idle_resources(accounts),
+            "oversized_instances": self.analyze_rightsizing_opportunities(accounts),
+            "unattached_storage": self.find_orphaned_ebs_volumes(accounts),
+            "old_snapshots": self.find_old_snapshots(accounts),
+            "unused_elastic_ips": self.find_unused_elastic_ips(accounts),
+            "underutilized_rds": self.find_underutilized_rds(accounts),
+            "lambda_over_provisioned": self.find_lambda_waste(accounts),
+            "unused_load_balancers": self.find_unused_load_balancers(accounts),
+            "storage_class_optimization": self.analyze_s3_storage_class(accounts),
+            "cloudwatch_logs_retention": self.analyze_log_retention(accounts),
             # Enhanced analysis for higher savings
-            'nat_gateway_optimization': self.find_nat_gateway_waste(accounts),
-            'cloudtrail_optimization': self.find_cloudtrail_waste(accounts),
-            'cloudwatch_metrics_waste': self.find_cloudwatch_metrics_waste(accounts),
-            'unused_security_groups': self.find_unused_security_groups(accounts),
-            'reserved_instance_opportunities': self.analyze_reserved_instance_opportunities(accounts)
+            "nat_gateway_optimization": self.find_nat_gateway_waste(accounts),
+            "cloudtrail_optimization": self.find_cloudtrail_waste(accounts),
+            "cloudwatch_metrics_waste": self.find_cloudwatch_metrics_waste(accounts),
+            "unused_security_groups": self.find_unused_security_groups(accounts),
+            "reserved_instance_opportunities": self.analyze_reserved_instance_opportunities(accounts),
         }
-        
+
         # Consolidate all opportunities
         all_opportunities = []
         total_monthly_savings = 0
-        
+
         for pattern, opportunities in waste_patterns.items():
             all_opportunities.extend(opportunities)
             pattern_savings = sum(op.potential_savings for op in opportunities)
             total_monthly_savings += pattern_savings
             print(f"  📊 {pattern}: {len(opportunities)} opportunities, ${pattern_savings:,.0f}/month")
-        
+
         self.opportunities = all_opportunities
         print(f"💰 Total identified: ${total_monthly_savings:,.0f}/month (${total_monthly_savings * 12:,.0f}/year)")
-        
+
         return waste_patterns
-    
+
     def find_idle_resources(self, accounts: List[str]) -> List[CostSavingsOpportunity]:
         """Find idle EC2 instances with minimal CPU utilization."""
         opportunities = []
-        
+
         if not accounts:
             accounts = self._get_all_accounts()
-        
+
         with ThreadPoolExecutor(max_workers=10) as executor:
             futures = [executor.submit(self._analyze_idle_ec2, account) for account in accounts]
-            
+
             for future in as_completed(futures):
                 try:
                     account_opportunities = future.result()
                     opportunities.extend(account_opportunities)
                 except Exception as e:
                     print(f"Error analyzing idle resources: {e}")
-        
+
         return opportunities
-    
+
     def _analyze_idle_ec2(self, account_id: str) -> List[CostSavingsOpportunity]:
         """Analyze EC2 instances for idle resources in a specific account."""
         opportunities = []
-        
+
         try:
             # Get session for account (would use cross-account role in production)
             session = self._get_account_session(account_id)
-            ec2 = session.client('ec2')
-            cloudwatch = session.client('cloudwatch')
-            
+            ec2 = session.client("ec2")
+            cloudwatch = session.client("cloudwatch")
+
             # Get all running instances
-            response = ec2.describe_instances(Filters=[{'Name': 'state', 'Values': ['running']}])
-            
-            for reservation in response['Reservations']:
-                for instance in reservation['Instances']:
-                    instance_id = instance['InstanceId']
-                    
+            response = ec2.describe_instances(Filters=[{"Name": "state", "Values": ["running"]}])
+
+            for reservation in response["Reservations"]:
+                for instance in reservation["Instances"]:
+                    instance_id = instance["InstanceId"]
+
                     # Check CPU utilization over last 30 days
-                    cpu_utilization = self._get_cpu_utilization(
-                        cloudwatch, instance_id, days=30
-                    )
-                    
+                    cpu_utilization = self._get_cpu_utilization(cloudwatch, instance_id, days=30)
+
                     if cpu_utilization < 5.0:  # Less than 5% average CPU
-                        monthly_cost = self._estimate_ec2_monthly_cost(instance['InstanceType'])
-                        
+                        monthly_cost = self._estimate_ec2_monthly_cost(instance["InstanceType"])
+
                         opportunity = CostSavingsOpportunity(
-                            resource_type='ec2_instance',
+                            resource_type="ec2_instance",
                             resource_id=instance_id,
                             account_id=account_id,
                             current_cost=monthly_cost,
                             potential_savings=monthly_cost * 0.9,  # 90% savings by terminating
-                            confidence='high',
-                            action_required='terminate_or_rightsize',
-                            implementation_effort='low',
-                            business_impact='medium'
+                            confidence="high",
+                            action_required="terminate_or_rightsize",
+                            implementation_effort="low",
+                            business_impact="medium",
                         )
                         opportunities.append(opportunity)
-        
+
         except Exception as e:
             print(f"Error analyzing account {account_id}: {e}")
-        
+
         return opportunities
-    
+
     def analyze_rightsizing_opportunities(self, accounts: List[str]) -> List[CostSavingsOpportunity]:
         """Identify EC2 instances that can be rightsized."""
         opportunities = []
-        
+
         # Rightsizing analysis logic
         rightsizing_rules = {
-            'cpu_utilization': {'threshold': 20, 'savings_potential': 0.3},
-            'memory_utilization': {'threshold': 30, 'savings_potential': 0.25},
-            'network_utilization': {'threshold': 10, 'savings_potential': 0.15}
+            "cpu_utilization": {"threshold": 20, "savings_potential": 0.3},
+            "memory_utilization": {"threshold": 30, "savings_potential": 0.25},
+            "network_utilization": {"threshold": 10, "savings_potential": 0.15},
         }
-        
+
         for account_id in accounts or self._get_all_accounts():
             try:
                 session = self._get_account_session(account_id)
-                ec2 = session.client('ec2')
-                cloudwatch = session.client('cloudwatch')
-                
+                ec2 = session.client("ec2")
+                cloudwatch = session.client("cloudwatch")
+
                 instances = self._get_running_instances(ec2)
-                
+
                 for instance in instances:
-                    instance_type = instance['InstanceType']
+                    instance_type = instance["InstanceType"]
                     current_cost = self._estimate_ec2_monthly_cost(instance_type)
-                    
+
                     # Analyze utilization patterns
-                    utilization = self._analyze_instance_utilization(
-                        cloudwatch, instance['InstanceId']
-                    )
-                    
+                    utilization = self._analyze_instance_utilization(cloudwatch, instance["InstanceId"])
+
                     # Calculate potential savings
-                    if utilization['cpu_avg'] < 20 and utilization['memory_avg'] < 30:
+                    if utilization["cpu_avg"] < 20 and utilization["memory_avg"] < 30:
                         smaller_instance = self._suggest_smaller_instance(instance_type)
                         if smaller_instance:
                             smaller_cost = self._estimate_ec2_monthly_cost(smaller_instance)
-                            
+
                             opportunity = CostSavingsOpportunity(
-                                resource_type='ec2_instance',
-                                resource_id=instance['InstanceId'],
+                                resource_type="ec2_instance",
+                                resource_id=instance["InstanceId"],
                                 account_id=account_id,
                                 current_cost=current_cost,
                                 potential_savings=current_cost - smaller_cost,
-                                confidence='high',
-                                action_required=f'rightsize_to_{smaller_instance}',
-                                implementation_effort='medium',
-                                business_impact='low'
+                                confidence="high",
+                                action_required=f"rightsize_to_{smaller_instance}",
+                                implementation_effort="medium",
+                                business_impact="low",
                             )
                             opportunities.append(opportunity)
-            
+
             except Exception as e:
                 print(f"Error analyzing rightsizing for account {account_id}: {e}")
-        
+
         return opportunities
-    
+
     def find_orphaned_ebs_volumes(self, accounts: List[str]) -> List[CostSavingsOpportunity]:
         """Find unattached EBS volumes."""
         opportunities = []
-        
+
         for account_id in accounts or self._get_all_accounts():
             try:
                 session = self._get_account_session(account_id)
-                ec2 = session.client('ec2')
-                
+                ec2 = session.client("ec2")
+
                 # Get all unattached volumes
-                response = ec2.describe_volumes(
-                    Filters=[{'Name': 'status', 'Values': ['available']}]
-                )
-                
-                for volume in response['Volumes']:
-                    volume_id = volume['VolumeId']
-                    size_gb = volume['Size']
-                    volume_type = volume['VolumeType']
-                    
+                response = ec2.describe_volumes(Filters=[{"Name": "status", "Values": ["available"]}])
+
+                for volume in response["Volumes"]:
+                    volume_id = volume["VolumeId"]
+                    size_gb = volume["Size"]
+                    volume_type = volume["VolumeType"]
+
                     # Calculate monthly cost
                     monthly_cost = self._calculate_ebs_cost(size_gb, volume_type)
-                    
+
                     opportunity = CostSavingsOpportunity(
-                        resource_type='ebs_volume',
+                        resource_type="ebs_volume",
                         resource_id=volume_id,
                         account_id=account_id,
                         current_cost=monthly_cost,
                         potential_savings=monthly_cost,  # 100% savings by deletion
-                        confidence='high',
-                        action_required='delete_after_snapshot',
-                        implementation_effort='low',
-                        business_impact='low'
+                        confidence="high",
+                        action_required="delete_after_snapshot",
+                        implementation_effort="low",
+                        business_impact="low",
                     )
                     opportunities.append(opportunity)
-            
+
             except Exception as e:
                 print(f"Error finding orphaned volumes in {account_id}: {e}")
-        
+
         return opportunities
-    
+
     def find_old_snapshots(self, accounts: List[str]) -> List[CostSavingsOpportunity]:
         """Find old EBS snapshots older than retention policy."""
         opportunities = []
         cutoff_date = datetime.now() - timedelta(days=90)  # 90-day retention
-        
+
         for account_id in accounts or self._get_all_accounts():
             try:
                 session = self._get_account_session(account_id)
-                ec2 = session.client('ec2')
-                
-                response = ec2.describe_snapshots(OwnerIds=['self'])
-                
-                for snapshot in response['Snapshots']:
-                    start_time = snapshot['StartTime'].replace(tzinfo=None)
-                    
+                ec2 = session.client("ec2")
+
+                response = ec2.describe_snapshots(OwnerIds=["self"])
+
+                for snapshot in response["Snapshots"]:
+                    start_time = snapshot["StartTime"].replace(tzinfo=None)
+
                     if start_time < cutoff_date:
                         # Estimate snapshot cost (approximately $0.05 per GB per month)
-                        volume_size = snapshot.get('VolumeSize', 0)
+                        volume_size = snapshot.get("VolumeSize", 0)
                         monthly_cost = volume_size * 0.05
-                        
+
                         opportunity = CostSavingsOpportunity(
-                            resource_type='ebs_snapshot',
-                            resource_id=snapshot['SnapshotId'],
+                            resource_type="ebs_snapshot",
+                            resource_id=snapshot["SnapshotId"],
                             account_id=account_id,
                             current_cost=monthly_cost,
                             potential_savings=monthly_cost,
-                            confidence='medium',
-                            action_required='delete_old_snapshot',
-                            implementation_effort='low',
-                            business_impact='low'
+                            confidence="medium",
+                            action_required="delete_old_snapshot",
+                            implementation_effort="low",
+                            business_impact="low",
                         )
                         opportunities.append(opportunity)
-            
+
             except Exception as e:
                 print(f"Error finding old snapshots in {account_id}: {e}")
-        
+
         return opportunities
-    
+
     def calculate_total_savings(self) -> Dict[str, float]:
         """Calculate total potential savings from all opportunities."""
         if not self.opportunities:
-            return {'monthly': 0, 'annual': 0, 'percentage': 0}
-        
+            return {"monthly": 0, "annual": 0, "percentage": 0}
+
         total_monthly_savings = sum(op.potential_savings for op in self.opportunities)
         total_annual_savings = total_monthly_savings * 12
-        
+
         # Estimate current spend (this would come from Cost Explorer in production)
         estimated_current_monthly_spend = 292000  # $3.5M annual / 12 months
         savings_percentage = (total_monthly_savings / estimated_current_monthly_spend) * 100
-        
+
         return {
-            'monthly': total_monthly_savings,
-            'annual': total_annual_savings,
-            'percentage': min(savings_percentage, 100)
+            "monthly": total_monthly_savings,
+            "annual": total_annual_savings,
+            "percentage": min(savings_percentage, 100),
         }
-    
+
     def generate_savings_report(self) -> Dict[str, Any]:
         """Generate comprehensive cost savings report."""
         savings_summary = self.calculate_total_savings()
-        
+
         # Group opportunities by type
         opportunities_by_type = {}
         for op in self.opportunities:
             if op.resource_type not in opportunities_by_type:
                 opportunities_by_type[op.resource_type] = []
             opportunities_by_type[op.resource_type].append(op)
-        
+
         # Calculate savings by type
         savings_by_type = {}
         for resource_type, opportunities in opportunities_by_type.items():
             total_savings = sum(op.potential_savings for op in opportunities)
             savings_by_type[resource_type] = {
-                'count': len(opportunities),
-                'monthly_savings': total_savings,
-                'annual_savings': total_savings * 12
+                "count": len(opportunities),
+                "monthly_savings": total_savings,
+                "annual_savings": total_savings * 12,
             }
-        
+
         report = {
-            'metadata': {
-                'generated_at': datetime.now().isoformat(),
-                'target_savings_percent': self.target_savings_percent,
-                'analysis_scope': 'all_accounts',
-                'total_opportunities': len(self.opportunities)
+            "metadata": {
+                "generated_at": datetime.now().isoformat(),
+                "target_savings_percent": self.target_savings_percent,
+                "analysis_scope": "all_accounts",
+                "total_opportunities": len(self.opportunities),
             },
-            'summary': savings_summary,
-            'by_resource_type': savings_by_type,
-            'top_opportunities': self._get_top_opportunities(10),
-            'quick_wins': self._get_quick_wins(),
-            'recommendations': self._generate_recommendations()
+            "summary": savings_summary,
+            "by_resource_type": savings_by_type,
+            "top_opportunities": self._get_top_opportunities(10),
+            "quick_wins": self._get_quick_wins(),
+            "recommendations": self._generate_recommendations(),
         }
-        
+
         # Save report
         self._save_report(report)
-        
+
         return report
-    
+
     def _get_top_opportunities(self, limit: int = 10) -> List[Dict]:
         """Get top savings opportunities sorted by potential savings."""
-        sorted_opportunities = sorted(
-            self.opportunities, 
-            key=lambda x: x.potential_savings, 
-            reverse=True
-        )
-        
+        sorted_opportunities = sorted(self.opportunities, key=lambda x: x.potential_savings, reverse=True)
+
         return [
             {
-                'resource_type': op.resource_type,
-                'resource_id': op.resource_id,
-                'account_id': op.account_id,
-                'monthly_savings': op.potential_savings,
-                'annual_savings': op.potential_savings * 12,
-                'confidence': op.confidence,
-                'action': op.action_required
+                "resource_type": op.resource_type,
+                "resource_id": op.resource_id,
+                "account_id": op.account_id,
+                "monthly_savings": op.potential_savings,
+                "annual_savings": op.potential_savings * 12,
+                "confidence": op.confidence,
+                "action": op.action_required,
             }
             for op in sorted_opportunities[:limit]
         ]
-    
+
     def _get_quick_wins(self) -> List[Dict]:
         """Get quick win opportunities (low effort, high impact)."""
-        quick_wins = [
-            op for op in self.opportunities
-            if op.implementation_effort == 'low' and op.confidence == 'high'
-        ]
-        
+        quick_wins = [op for op in self.opportunities if op.implementation_effort == "low" and op.confidence == "high"]
+
         return [
             {
-                'resource_type': op.resource_type,
-                'resource_id': op.resource_id,
-                'monthly_savings': op.potential_savings,
-                'action': op.action_required
+                "resource_type": op.resource_type,
+                "resource_id": op.resource_id,
+                "monthly_savings": op.potential_savings,
+                "action": op.action_required,
             }
             for op in sorted(quick_wins, key=lambda x: x.potential_savings, reverse=True)
         ]
-    
+
     def _generate_recommendations(self) -> List[str]:
         """Generate strategic recommendations based on analysis."""
         total_savings = self.calculate_total_savings()
-        
+
         recommendations = []
-        
-        if total_savings['percentage'] >= self.target_savings_percent:
+
+        if total_savings["percentage"] >= self.target_savings_percent:
             recommendations.append(
                 f"✅ Target of {self.target_savings_percent}% savings achievable "
                 f"(identified {total_savings['percentage']:.1f}%)"
@@ -401,422 +400,424 @@ class CostOptimizer:
                 f"⚠️ Additional analysis needed to reach {self.target_savings_percent}% target "
                 f"(current: {total_savings['percentage']:.1f}%)"
             )
-        
+
         # Add specific recommendations
         quick_wins = self._get_quick_wins()
         if quick_wins:
-            quick_win_savings = sum(op['monthly_savings'] for op in quick_wins[:5])
-            recommendations.append(
-                f"🚀 Implement top 5 quick wins first: ${quick_win_savings:,.0f}/month savings"
-            )
-        
-        recommendations.extend([
-            "📊 Prioritize high-confidence, low-effort opportunities",
-            "🔄 Implement automated cleanup for orphaned resources",
-            "📈 Set up continuous cost monitoring and alerts",
-            "🎯 Focus on rightsizing before Reserved Instance purchases"
-        ])
-        
+            quick_win_savings = sum(op["monthly_savings"] for op in quick_wins[:5])
+            recommendations.append(f"🚀 Implement top 5 quick wins first: ${quick_win_savings:,.0f}/month savings")
+
+        recommendations.extend(
+            [
+                "📊 Prioritize high-confidence, low-effort opportunities",
+                "🔄 Implement automated cleanup for orphaned resources",
+                "📈 Set up continuous cost monitoring and alerts",
+                "🎯 Focus on rightsizing before Reserved Instance purchases",
+            ]
+        )
+
         return recommendations
-    
+
     def _save_report(self, report: Dict[str, Any]):
         """Save cost optimization report to artifacts."""
         import os
-        
-        os.makedirs('artifacts/sprint-1/finops', exist_ok=True)
-        
+
+        os.makedirs("artifacts/sprint-1/finops", exist_ok=True)
+
         # Save JSON report
-        with open('artifacts/sprint-1/finops/cost-optimization-report.json', 'w') as f:
+        with open("artifacts/sprint-1/finops/cost-optimization-report.json", "w") as f:
             json.dump(report, f, indent=2, default=str)
-        
+
         # Save CSV summary
         import csv
-        with open('artifacts/sprint-1/finops/savings-opportunities.csv', 'w', newline='') as f:
+
+        with open("artifacts/sprint-1/finops/savings-opportunities.csv", "w", newline="") as f:
             writer = csv.writer(f)
-            writer.writerow([
-                'Resource Type', 'Resource ID', 'Account ID', 
-                'Monthly Savings', 'Annual Savings', 'Confidence', 'Action Required'
-            ])
-            
+            writer.writerow(
+                [
+                    "Resource Type",
+                    "Resource ID",
+                    "Account ID",
+                    "Monthly Savings",
+                    "Annual Savings",
+                    "Confidence",
+                    "Action Required",
+                ]
+            )
+
             for op in self.opportunities:
-                writer.writerow([
-                    op.resource_type, op.resource_id, op.account_id,
-                    f"${op.potential_savings:,.2f}", 
-                    f"${op.potential_savings * 12:,.2f}",
-                    op.confidence, op.action_required
-                ])
-        
+                writer.writerow(
+                    [
+                        op.resource_type,
+                        op.resource_id,
+                        op.account_id,
+                        f"${op.potential_savings:,.2f}",
+                        f"${op.potential_savings * 12:,.2f}",
+                        op.confidence,
+                        op.action_required,
+                    ]
+                )
+
         print("💰 Cost optimization report saved:")
         print("  - artifacts/sprint-1/finops/cost-optimization-report.json")
         print("  - artifacts/sprint-1/finops/savings-opportunities.csv")
-    
+
     # Helper methods
     def _get_all_accounts(self) -> List[str]:
         """Get all AWS accounts from Organizations (enhanced for multi-account org)."""
         # Enhanced mock for multi-account organization
-        base_accounts = ['123456789012', '234567890123', '345678901234']
-        
+        base_accounts = ["123456789012", "234567890123", "345678901234"]
+
         # Generate additional accounts to simulate large organization
         additional_accounts = []
         for i in range(4, self.max_accounts + 1):
             # Generate realistic account IDs
             account_id = str(100000000000 + i * 11111)
             additional_accounts.append(account_id)
-        
+
         all_accounts = base_accounts + additional_accounts
         print(f"📊 Discovered {len(all_accounts)} accounts in organization")
         return all_accounts
-    
+
     def _get_account_session(self, account_id: str):
         """Get boto3 session for specific account."""
         # In production, would assume cross-account role
         return self.session
-    
+
     def _estimate_ec2_monthly_cost(self, instance_type: str) -> float:
         """Estimate monthly EC2 cost."""
         hourly_costs = {
-            't2.micro': 0.0116, 't2.small': 0.023, 't2.medium': 0.046,
-            't3.micro': 0.0104, 't3.small': 0.021, 't3.medium': 0.042,
-            'm5.large': 0.096, 'm5.xlarge': 0.192, 'm5.2xlarge': 0.384,
-            'm5.4xlarge': 0.768, 'm5.8xlarge': 1.536
+            "t2.micro": 0.0116,
+            "t2.small": 0.023,
+            "t2.medium": 0.046,
+            "t3.micro": 0.0104,
+            "t3.small": 0.021,
+            "t3.medium": 0.042,
+            "m5.large": 0.096,
+            "m5.xlarge": 0.192,
+            "m5.2xlarge": 0.384,
+            "m5.4xlarge": 0.768,
+            "m5.8xlarge": 1.536,
         }
         hourly = hourly_costs.get(instance_type, 0.1)
         return hourly * 24 * 30
-    
+
     def _calculate_ebs_cost(self, size_gb: int, volume_type: str) -> float:
         """Calculate monthly EBS cost."""
-        rates = {
-            'gp2': 0.10,
-            'gp3': 0.08,
-            'io1': 0.125,
-            'io2': 0.125,
-            'st1': 0.045,
-            'sc1': 0.025
-        }
+        rates = {"gp2": 0.10, "gp3": 0.08, "io1": 0.125, "io2": 0.125, "st1": 0.045, "sc1": 0.025}
         rate = rates.get(volume_type, 0.10)
         return size_gb * rate
-    
+
     def _get_cpu_utilization(self, cloudwatch, instance_id: str, days: int = 30) -> float:
         """Get average CPU utilization for instance."""
         # Mock implementation - in production would query CloudWatch
         return 3.5  # Mock low utilization
-    
+
     def _get_running_instances(self, ec2_client):
         """Get all running EC2 instances."""
-        response = ec2_client.describe_instances(
-            Filters=[{'Name': 'state', 'Values': ['running']}]
-        )
+        response = ec2_client.describe_instances(Filters=[{"Name": "state", "Values": ["running"]}])
         instances = []
-        for reservation in response['Reservations']:
-            instances.extend(reservation['Instances'])
+        for reservation in response["Reservations"]:
+            instances.extend(reservation["Instances"])
         return instances
-    
+
     def _analyze_instance_utilization(self, cloudwatch, instance_id: str) -> Dict[str, float]:
         """Analyze instance utilization metrics."""
         # Mock implementation
-        return {
-            'cpu_avg': 15.0,
-            'memory_avg': 25.0,
-            'network_avg': 5.0
-        }
-    
+        return {"cpu_avg": 15.0, "memory_avg": 25.0, "network_avg": 5.0}
+
     def _suggest_smaller_instance(self, current_type: str) -> Optional[str]:
         """Suggest a smaller instance type."""
         downsizing_map = {
-            'm5.2xlarge': 'm5.xlarge',
-            'm5.xlarge': 'm5.large',
-            'm5.large': 'm5.medium',
-            't3.large': 't3.medium',
-            't3.medium': 't3.small'
+            "m5.2xlarge": "m5.xlarge",
+            "m5.xlarge": "m5.large",
+            "m5.large": "m5.medium",
+            "t3.large": "t3.medium",
+            "t3.medium": "t3.small",
         }
         return downsizing_map.get(current_type)
-    
+
     # Additional methods for other resource types
     def find_unused_elastic_ips(self, accounts: List[str]) -> List[CostSavingsOpportunity]:
         """Find unused Elastic IP addresses."""
         return []  # Implementation placeholder
-    
+
     def find_underutilized_rds(self, accounts: List[str]) -> List[CostSavingsOpportunity]:
         """Find underutilized RDS instances."""
         return []  # Implementation placeholder
-    
+
     def find_lambda_waste(self, accounts: List[str]) -> List[CostSavingsOpportunity]:
         """Find over-provisioned Lambda functions."""
         return []  # Implementation placeholder
-    
+
     def find_unused_load_balancers(self, accounts: List[str]) -> List[CostSavingsOpportunity]:
         """Find unused load balancers."""
         return []  # Implementation placeholder
-    
+
     def analyze_s3_storage_class(self, accounts: List[str]) -> List[CostSavingsOpportunity]:
         """Analyze S3 storage class optimization."""
         return []  # Implementation placeholder
-    
+
     def analyze_log_retention(self, accounts: List[str]) -> List[CostSavingsOpportunity]:
         """Analyze CloudWatch log retention optimization."""
         opportunities = []
-        
+
         for account_id in accounts or self._get_all_accounts():
             try:
                 session = self._get_account_session(account_id)
-                logs_client = session.client('logs')
-                
+                logs_client = session.client("logs")
+
                 response = logs_client.describe_log_groups()
-                
-                for log_group in response.get('logGroups', []):
-                    log_group_name = log_group['logGroupName']
-                    retention_days = log_group.get('retentionInDays')
-                    
+
+                for log_group in response.get("logGroups", []):
+                    log_group_name = log_group["logGroupName"]
+                    retention_days = log_group.get("retentionInDays")
+
                     # If retention is not set or too long (default is "never expire")
                     if not retention_days or retention_days > 90:
                         # Estimate savings from setting 30-day retention
                         estimated_monthly_cost = 50  # Mock estimate
                         potential_savings = estimated_monthly_cost * 0.6  # 60% reduction
-                        
+
                         opportunity = CostSavingsOpportunity(
-                            resource_type='cloudwatch_log_group',
+                            resource_type="cloudwatch_log_group",
                             resource_id=log_group_name,
                             account_id=account_id,
                             current_cost=estimated_monthly_cost,
                             potential_savings=potential_savings,
-                            confidence='medium',
-                            action_required='set_log_retention_30_days',
-                            implementation_effort='low',
-                            business_impact='low'
+                            confidence="medium",
+                            action_required="set_log_retention_30_days",
+                            implementation_effort="low",
+                            business_impact="low",
                         )
                         opportunities.append(opportunity)
-                        
+
             except Exception as e:
                 print(f"Error analyzing log retention for {account_id}: {e}")
-        
+
         return opportunities
-        
+
     def find_nat_gateway_waste(self, accounts: List[str]) -> List[CostSavingsOpportunity]:
         """Find underutilized or unnecessary NAT Gateways."""
         opportunities = []
-        
+
         for account_id in accounts or self._get_all_accounts():
             try:
                 session = self._get_account_session(account_id)
-                ec2 = session.client('ec2')
-                
+                ec2 = session.client("ec2")
+
                 # Get all NAT Gateways
                 response = ec2.describe_nat_gateways()
-                
-                for nat_gw in response.get('NatGateways', []):
-                    if nat_gw['State'] == 'available':
-                        nat_gw_id = nat_gw['NatGatewayId']
-                        
+
+                for nat_gw in response.get("NatGateways", []):
+                    if nat_gw["State"] == "available":
+                        nat_gw_id = nat_gw["NatGatewayId"]
+
                         # NAT Gateway costs ~$45/month + data transfer
                         base_cost = 45
                         data_transfer_cost = 30  # Estimated
                         total_monthly_cost = base_cost + data_transfer_cost
-                        
+
                         # Check if it's actually being used (simplified check)
                         # In production, would check route tables and traffic metrics
                         opportunity = CostSavingsOpportunity(
-                            resource_type='nat_gateway',
+                            resource_type="nat_gateway",
                             resource_id=nat_gw_id,
                             account_id=account_id,
                             current_cost=total_monthly_cost,
                             potential_savings=total_monthly_cost * 0.8,  # 80% savings potential
-                            confidence='medium',
-                            action_required='evaluate_nat_gateway_necessity',
-                            implementation_effort='medium',
-                            business_impact='low'
+                            confidence="medium",
+                            action_required="evaluate_nat_gateway_necessity",
+                            implementation_effort="medium",
+                            business_impact="low",
                         )
                         opportunities.append(opportunity)
-                        
+
             except Exception as e:
                 print(f"Error analyzing NAT Gateways for {account_id}: {e}")
-        
+
         return opportunities
-        
+
     def find_cloudtrail_waste(self, accounts: List[str]) -> List[CostSavingsOpportunity]:
         """Find CloudTrail logging waste and optimization opportunities."""
         opportunities = []
-        
+
         for account_id in accounts or self._get_all_accounts():
             try:
                 session = self._get_account_session(account_id)
-                cloudtrail = session.client('cloudtrail')
-                
+                cloudtrail = session.client("cloudtrail")
+
                 response = cloudtrail.describe_trails()
-                
-                for trail in response.get('trailList', []):
-                    trail_name = trail['Name']
-                    
+
+                for trail in response.get("trailList", []):
+                    trail_name = trail["Name"]
+
                     # Check for multiple overlapping trails
-                    if trail.get('IsMultiRegionTrail', False):
+                    if trail.get("IsMultiRegionTrail", False):
                         # Estimate CloudTrail costs - data events can be expensive
                         estimated_monthly_cost = 25  # Base cost
-                        
+
                         # Check if data events are enabled (costly)
                         try:
                             event_selectors = cloudtrail.get_event_selectors(TrailName=trail_name)
-                            if event_selectors.get('EventSelectors'):
+                            if event_selectors.get("EventSelectors"):
                                 estimated_monthly_cost += 150  # Data events are expensive
-                                
+
                                 opportunity = CostSavingsOpportunity(
-                                    resource_type='cloudtrail_data_events',
+                                    resource_type="cloudtrail_data_events",
                                     resource_id=trail_name,
                                     account_id=account_id,
                                     current_cost=estimated_monthly_cost,
                                     potential_savings=150,  # Save on data events
-                                    confidence='medium',
-                                    action_required='optimize_cloudtrail_data_events',
-                                    implementation_effort='low',
-                                    business_impact='low'
+                                    confidence="medium",
+                                    action_required="optimize_cloudtrail_data_events",
+                                    implementation_effort="low",
+                                    business_impact="low",
                                 )
                                 opportunities.append(opportunity)
                         except Exception:
                             pass
-                            
+
             except Exception as e:
                 print(f"Error analyzing CloudTrail for {account_id}: {e}")
-        
+
         return opportunities
-        
+
     def find_cloudwatch_metrics_waste(self, accounts: List[str]) -> List[CostSavingsOpportunity]:
         """Find unused CloudWatch custom metrics."""
         opportunities = []
-        
+
         for account_id in accounts or self._get_all_accounts():
             try:
                 session = self._get_account_session(account_id)
-                cloudwatch = session.client('cloudwatch')
-                
+                cloudwatch = session.client("cloudwatch")
+
                 # Get all custom metrics (simplified)
                 response = cloudwatch.list_metrics()
-                
-                custom_metrics_count = len([
-                    m for m in response.get('Metrics', [])
-                    if not m['Namespace'].startswith('AWS/')
-                ])
-                
+
+                custom_metrics_count = len(
+                    [m for m in response.get("Metrics", []) if not m["Namespace"].startswith("AWS/")]
+                )
+
                 if custom_metrics_count > 10:  # Threshold for optimization
                     # Custom metrics cost $0.30 per metric per month
                     estimated_cost = custom_metrics_count * 0.30
                     potential_savings = estimated_cost * 0.4  # 40% reduction
-                    
+
                     opportunity = CostSavingsOpportunity(
-                        resource_type='cloudwatch_custom_metrics',
-                        resource_id=f'{custom_metrics_count}_custom_metrics',
+                        resource_type="cloudwatch_custom_metrics",
+                        resource_id=f"{custom_metrics_count}_custom_metrics",
                         account_id=account_id,
                         current_cost=estimated_cost,
                         potential_savings=potential_savings,
-                        confidence='medium',
-                        action_required='cleanup_unused_custom_metrics',
-                        implementation_effort='medium',
-                        business_impact='low'
+                        confidence="medium",
+                        action_required="cleanup_unused_custom_metrics",
+                        implementation_effort="medium",
+                        business_impact="low",
                     )
                     opportunities.append(opportunity)
-                    
+
             except Exception as e:
                 print(f"Error analyzing CloudWatch metrics for {account_id}: {e}")
-        
+
         return opportunities
-        
+
     def find_unused_security_groups(self, accounts: List[str]) -> List[CostSavingsOpportunity]:
         """Find unused security groups (no direct cost but operational overhead)."""
         opportunities = []
-        
+
         # Note: Security groups don't have direct costs, but unused ones create
         # operational overhead and potential security risks
         for account_id in accounts or self._get_all_accounts():
             try:
                 session = self._get_account_session(account_id)
-                ec2 = session.client('ec2')
-                
+                ec2 = session.client("ec2")
+
                 # Get all security groups
                 response = ec2.describe_security_groups()
-                all_sgs = response['SecurityGroups']
-                
+                all_sgs = response["SecurityGroups"]
+
                 # Get all network interfaces to find used security groups
                 ni_response = ec2.describe_network_interfaces()
                 used_sg_ids = set()
-                
-                for ni in ni_response['NetworkInterfaces']:
-                    for sg in ni.get('Groups', []):
-                        used_sg_ids.add(sg['GroupId'])
-                
-                unused_sgs = [sg for sg in all_sgs if sg['GroupId'] not in used_sg_ids and sg['GroupName'] != 'default']
-                
+
+                for ni in ni_response["NetworkInterfaces"]:
+                    for sg in ni.get("Groups", []):
+                        used_sg_ids.add(sg["GroupId"])
+
+                unused_sgs = [sg for sg in all_sgs if sg["GroupId"] not in used_sg_ids and sg["GroupName"] != "default"]
+
                 if len(unused_sgs) > 5:  # Only report if significant number
                     # No direct cost savings, but operational efficiency
                     opportunity = CostSavingsOpportunity(
-                        resource_type='unused_security_groups',
-                        resource_id=f'{len(unused_sgs)}_unused_sgs',
+                        resource_type="unused_security_groups",
+                        resource_id=f"{len(unused_sgs)}_unused_sgs",
                         account_id=account_id,
                         current_cost=0,  # No direct cost
                         potential_savings=0,  # Operational benefits
-                        confidence='high',
-                        action_required='cleanup_unused_security_groups',
-                        implementation_effort='low',
-                        business_impact='low'
+                        confidence="high",
+                        action_required="cleanup_unused_security_groups",
+                        implementation_effort="low",
+                        business_impact="low",
                     )
                     opportunities.append(opportunity)
-                    
+
             except Exception as e:
                 print(f"Error analyzing security groups for {account_id}: {e}")
-        
+
         return opportunities
-        
+
     def analyze_reserved_instance_opportunities(self, accounts: List[str]) -> List[CostSavingsOpportunity]:
         """Analyze Reserved Instance purchase opportunities."""
         opportunities = []
-        
+
         for account_id in accounts or self._get_all_accounts():
             try:
                 session = self._get_account_session(account_id)
-                ec2 = session.client('ec2')
-                
+                ec2 = session.client("ec2")
+
                 # Get running instances
-                instances_response = ec2.describe_instances(
-                    Filters=[{'Name': 'state', 'Values': ['running']}]
-                )
-                
+                instances_response = ec2.describe_instances(Filters=[{"Name": "state", "Values": ["running"]}])
+
                 # Count instances by type
                 instance_types = {}
-                for reservation in instances_response['Reservations']:
-                    for instance in reservation['Instances']:
-                        instance_type = instance['InstanceType']
+                for reservation in instances_response["Reservations"]:
+                    for instance in reservation["Instances"]:
+                        instance_type = instance["InstanceType"]
                         instance_types[instance_type] = instance_types.get(instance_type, 0) + 1
-                
+
                 # Get existing RIs
-                ri_response = ec2.describe_reserved_instances(
-                    Filters=[{'Name': 'state', 'Values': ['active']}]
-                )
-                
+                ri_response = ec2.describe_reserved_instances(Filters=[{"Name": "state", "Values": ["active"]}])
+
                 reserved_by_type = {}
-                for ri in ri_response['ReservedInstances']:
-                    instance_type = ri['InstanceType']
-                    reserved_by_type[instance_type] = reserved_by_type.get(instance_type, 0) + ri['InstanceCount']
-                
+                for ri in ri_response["ReservedInstances"]:
+                    instance_type = ri["InstanceType"]
+                    reserved_by_type[instance_type] = reserved_by_type.get(instance_type, 0) + ri["InstanceCount"]
+
                 # Calculate RI opportunities
                 for instance_type, running_count in instance_types.items():
                     reserved_count = reserved_by_type.get(instance_type, 0)
                     unreserved_count = max(0, running_count - reserved_count)
-                    
+
                     if unreserved_count >= 3:  # Threshold for RI recommendation
                         monthly_on_demand = self._estimate_ec2_monthly_cost(instance_type)
                         monthly_ri = monthly_on_demand * 0.6  # ~40% savings with 1-year RI
                         monthly_savings = (monthly_on_demand - monthly_ri) * unreserved_count
-                        
+
                         opportunity = CostSavingsOpportunity(
-                            resource_type='reserved_instance_opportunity',
-                            resource_id=f'{instance_type}_{unreserved_count}_instances',
+                            resource_type="reserved_instance_opportunity",
+                            resource_id=f"{instance_type}_{unreserved_count}_instances",
                             account_id=account_id,
                             current_cost=monthly_on_demand * unreserved_count,
                             potential_savings=monthly_savings,
-                            confidence='high',
-                            action_required=f'purchase_reserved_instances_{instance_type}',
-                            implementation_effort='low',
-                            business_impact='low'
+                            confidence="high",
+                            action_required=f"purchase_reserved_instances_{instance_type}",
+                            implementation_effort="low",
+                            business_impact="low",
                         )
                         opportunities.append(opportunity)
-                        
+
             except Exception as e:
                 print(f"Error analyzing RI opportunities for {account_id}: {e}")
-        
-        return opportunities
+
+        return opportunities