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

runbooks/finops/automation_core.py

@@ -25,29 +25,39 @@ Strategic Alignment:
 import asyncio
 import logging
 import time
-from datetime import datetime, timedelta
-from typing import Any, Dict, List, Optional, Tuple, Union
 from dataclasses import dataclass, field
+from datetime import datetime, timedelta
 from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 import boto3
 from botocore.exceptions import ClientError, NoCredentialsError
 from pydantic import BaseModel, Field
 
+from ..common.profile_utils import get_profile_for_operation
 from ..common.rich_utils import (
-    console, print_header, print_success, print_error, print_warning, print_info,
-    create_table, create_progress_bar, format_cost, create_panel, STATUS_INDICATORS
+    STATUS_INDICATORS,
+    console,
+    create_panel,
+    create_progress_bar,
+    create_table,
+    format_cost,
+    print_error,
+    print_header,
+    print_info,
+    print_success,
+    print_warning,
 )
-from .embedded_mcp_validator import EmbeddedMCPValidator
-from ..common.profile_utils import get_profile_for_operation
+from .mcp_validator import EmbeddedMCPValidator
 
 logger = logging.getLogger(__name__)
 
 
 class OptimizationCategory(str, Enum):
     """Optimization categories for CloudOps automation consolidation."""
+
     COST_OPTIMIZATION = "cost_optimization"
-    SECURITY_COMPLIANCE = "security_compliance" 
+    SECURITY_COMPLIANCE = "security_compliance"
     RESOURCE_MANAGEMENT = "resource_management"
     NETWORK_INFRASTRUCTURE = "network_infrastructure"
     SPECIALIZED_OPERATIONS = "specialized_operations"
@@ -55,14 +65,16 @@ class OptimizationCategory(str, Enum):
 
 class BusinessImpactLevel(str, Enum):
     """Business impact levels for prioritization."""
-    HIGH = "high"          # >$1M annual impact
-    MEDIUM = "medium"      # $100K-$1M annual impact
-    LOW = "low"            # <$100K annual impact
+
+    HIGH = "high"  # >$1M annual impact
+    MEDIUM = "medium"  # $100K-$1M annual impact
+    LOW = "low"  # <$100K annual impact
 
 
 @dataclass
 class AutomationPattern:
     """Universal automation pattern from CloudOps consolidation."""
+
     name: str
     category: OptimizationCategory
     business_impact: BusinessImpactLevel
@@ -76,7 +88,7 @@ class AutomationPattern:
 class UniversalAutomationEngine:
     """
     Universal Automation Engine - Core Patterns from CloudOps-Automation Consolidation
-    
+
     Following $132,720+ methodology with proven automation patterns:
     - Multi-service AWS resource discovery and analysis
     - Universal cost calculation patterns across all optimization categories
@@ -85,33 +97,52 @@ class UniversalAutomationEngine:
     - MCP validation integration for evidence-based automation
     - Rich CLI integration for executive and technical stakeholder interfaces
     """
-    
+
     def __init__(self, profile_name: Optional[str] = None, regions: Optional[List[str]] = None):
         """Initialize universal automation engine with enterprise profile support."""
         self.profile_name = profile_name
         self.regions = regions or [
-            'us-east-1', 'us-west-2', 'us-east-2', 'us-west-1',
-            'eu-west-1', 'eu-central-1', 'ap-southeast-1', 'ap-northeast-1'
+            "us-east-1",
+            "us-west-2",
+            "us-east-2",
+            "us-west-1",
+            "eu-west-1",
+            "eu-central-1",
+            "ap-southeast-1",
+            "ap-northeast-1",
         ]
-        
+
         # Initialize AWS session with profile priority system
-        self.session = boto3.Session(
-            profile_name=get_profile_for_operation("operational", profile_name)
-        )
-        
+        self.session = boto3.Session(profile_name=get_profile_for_operation("operational", profile_name))
+
         # Universal automation patterns from CloudOps consolidation analysis
         self.automation_patterns = self._initialize_automation_patterns()
-        
+
         # All AWS regions for comprehensive discovery
         self.all_regions = [
-            'us-east-1', 'us-east-2', 'us-west-1', 'us-west-2',
-            'af-south-1', 'ap-east-1', 'ap-south-1', 'ap-northeast-1',
-            'ap-northeast-2', 'ap-northeast-3', 'ap-southeast-1', 'ap-southeast-2',
-            'ca-central-1', 'eu-central-1', 'eu-west-1', 'eu-west-2',
-            'eu-west-3', 'eu-south-1', 'eu-north-1', 'me-south-1',
-            'sa-east-1'
+            "us-east-1",
+            "us-east-2",
+            "us-west-1",
+            "us-west-2",
+            "af-south-1",
+            "ap-east-1",
+            "ap-south-1",
+            "ap-northeast-1",
+            "ap-northeast-2",
+            "ap-northeast-3",
+            "ap-southeast-1",
+            "ap-southeast-2",
+            "ca-central-1",
+            "eu-central-1",
+            "eu-west-1",
+            "eu-west-2",
+            "eu-west-3",
+            "eu-south-1",
+            "eu-north-1",
+            "me-south-1",
+            "sa-east-1",
         ]
-    
+
     def _initialize_automation_patterns(self) -> List[AutomationPattern]:
         """Initialize automation patterns from CloudOps-Automation consolidation analysis."""
         return [
@@ -122,15 +153,15 @@ class UniversalAutomationEngine:
                 business_impact=BusinessImpactLevel.HIGH,
                 aws_services=["EC2", "CloudWatch"],
                 annual_savings_potential=(1_500_000, 9_300_000),
-                implementation_weeks=3
+                implementation_weeks=3,
             ),
             AutomationPattern(
-                name="EC2 Instance Cost Optimization", 
+                name="EC2 Instance Cost Optimization",
                 category=OptimizationCategory.COST_OPTIMIZATION,
                 business_impact=BusinessImpactLevel.HIGH,
                 aws_services=["EC2", "CloudWatch", "Auto Scaling"],
                 annual_savings_potential=(2_000_000, 8_000_000),
-                implementation_weeks=4
+                implementation_weeks=4,
             ),
             AutomationPattern(
                 name="RDS Cost Optimization",
@@ -138,7 +169,7 @@ class UniversalAutomationEngine:
                 business_impact=BusinessImpactLevel.HIGH,
                 aws_services=["RDS", "CloudWatch"],
                 annual_savings_potential=(1_500_000, 6_000_000),
-                implementation_weeks=3
+                implementation_weeks=3,
             ),
             AutomationPattern(
                 name="Reserved Instance Optimization",
@@ -146,9 +177,8 @@ class UniversalAutomationEngine:
                 business_impact=BusinessImpactLevel.HIGH,
                 aws_services=["EC2", "RDS", "Redshift", "ElastiCache"],
                 annual_savings_potential=(3_200_000, 17_000_000),
-                implementation_weeks=5
+                implementation_weeks=5,
             ),
-            
             # Security & Compliance Patterns (15 notebooks → 4 modules)
             AutomationPattern(
                 name="IAM Security Optimization",
@@ -156,7 +186,7 @@ class UniversalAutomationEngine:
                 business_impact=BusinessImpactLevel.MEDIUM,
                 aws_services=["IAM", "CloudTrail"],
                 annual_savings_potential=(100_000, 500_000),
-                implementation_weeks=4
+                implementation_weeks=4,
             ),
             AutomationPattern(
                 name="S3 Security & Compliance",
@@ -164,9 +194,8 @@ class UniversalAutomationEngine:
                 business_impact=BusinessImpactLevel.MEDIUM,
                 aws_services=["S3", "CloudTrail"],
                 annual_savings_potential=(150_000, 800_000),
-                implementation_weeks=3
+                implementation_weeks=3,
             ),
-            
             # Resource Management Patterns (14 notebooks → 4 modules)
             AutomationPattern(
                 name="Resource Tagging & Governance",
@@ -174,7 +203,7 @@ class UniversalAutomationEngine:
                 business_impact=BusinessImpactLevel.MEDIUM,
                 aws_services=["EC2", "S3", "RDS", "Lambda"],
                 annual_savings_potential=(200_000, 1_000_000),
-                implementation_weeks=4
+                implementation_weeks=4,
             ),
             AutomationPattern(
                 name="Resource Lifecycle Management",
@@ -182,46 +211,46 @@ class UniversalAutomationEngine:
                 business_impact=BusinessImpactLevel.MEDIUM,
                 aws_services=["EC2", "EBS", "RDS"],
                 annual_savings_potential=(300_000, 1_500_000),
-                implementation_weeks=3
+                implementation_weeks=3,
             ),
         ]
-    
-    async def discover_resources_universal(self, 
-                                         service_types: List[str] = None,
-                                         optimization_focus: OptimizationCategory = None) -> Dict[str, Any]:
+
+    async def discover_resources_universal(
+        self, service_types: List[str] = None, optimization_focus: OptimizationCategory = None
+    ) -> Dict[str, Any]:
         """
         Universal resource discovery across all AWS services.
-        
+
         Args:
             service_types: List of AWS service names to discover (None = all)
             optimization_focus: Focus on specific optimization category
-            
+
         Returns:
             Comprehensive resource inventory with optimization opportunities
         """
         print_header("Universal Resource Discovery", "Enterprise Multi-Service Analysis")
-        
+
         discovery_start_time = time.time()
         service_types = service_types or ["EC2", "EBS", "S3", "RDS", "Lambda", "IAM"]
-        
+
         try:
             with create_progress_bar() as progress:
                 # Step 1: Multi-region service discovery
                 discovery_task = progress.add_task("Discovering resources...", total=len(self.regions))
                 resources = await self._discover_resources_by_service(service_types, progress, discovery_task)
-                
+
                 # Step 2: Optimization opportunity analysis
                 analysis_task = progress.add_task("Analyzing optimization opportunities...", total=len(resources))
                 optimization_opportunities = await self._analyze_optimization_opportunities(
                     resources, optimization_focus, progress, analysis_task
                 )
-                
+
                 # Step 3: Cost calculation and business impact
                 calculation_task = progress.add_task("Calculating business impact...", total=1)
                 business_impact = await self._calculate_business_impact(
                     optimization_opportunities, progress, calculation_task
                 )
-                
+
             discovery_results = {
                 "total_resources_discovered": sum(len(resources[service]) for service in resources),
                 "services_analyzed": list(resources.keys()),
@@ -229,187 +258,201 @@ class UniversalAutomationEngine:
                 "optimization_opportunities": optimization_opportunities,
                 "business_impact": business_impact,
                 "execution_time_seconds": time.time() - discovery_start_time,
-                "analysis_timestamp": datetime.now()
+                "analysis_timestamp": datetime.now(),
             }
-            
+
             # Display executive summary
             self._display_discovery_summary(discovery_results)
-            
+
             return discovery_results
-            
+
         except Exception as e:
             print_error(f"Universal resource discovery failed: {e}")
             logger.error(f"Discovery error: {e}", exc_info=True)
             raise
-    
-    async def _discover_resources_by_service(self, service_types: List[str], 
-                                           progress, task_id) -> Dict[str, List[Dict[str, Any]]]:
+
+    async def _discover_resources_by_service(
+        self, service_types: List[str], progress, task_id
+    ) -> Dict[str, List[Dict[str, Any]]]:
         """Discover resources by AWS service type across regions."""
         all_resources = {}
-        
+
         for region in self.regions:
             try:
                 for service_type in service_types:
                     if service_type not in all_resources:
                         all_resources[service_type] = []
-                    
+
                     # Service-specific discovery logic
                     service_resources = await self._discover_service_resources(service_type, region)
                     all_resources[service_type].extend(service_resources)
-                
+
                 print_info(f"Region {region}: {sum(len(all_resources[s]) for s in service_types)} resources discovered")
-                
+
             except ClientError as e:
                 print_warning(f"Region {region}: Access denied or region unavailable - {e.response['Error']['Code']}")
             except Exception as e:
                 print_error(f"Region {region}: Discovery error - {str(e)}")
-                
+
             progress.advance(task_id)
-        
+
         return all_resources
-    
+
     async def _discover_service_resources(self, service_type: str, region: str) -> List[Dict[str, Any]]:
         """Discover resources for specific AWS service type."""
         resources = []
-        
+
         try:
             if service_type == "EC2":
-                ec2_client = self.session.client('ec2', region_name=region)
+                ec2_client = self.session.client("ec2", region_name=region)
                 response = ec2_client.describe_instances()
-                for reservation in response.get('Reservations', []):
-                    for instance in reservation.get('Instances', []):
-                        resources.append({
-                            "resource_id": instance.get('InstanceId'),
-                            "resource_type": "EC2Instance",
-                            "region": region,
-                            "state": instance.get('State', {}).get('Name'),
-                            "instance_type": instance.get('InstanceType'),
-                            "tags": {tag['Key']: tag['Value'] for tag in instance.get('Tags', [])},
-                            "launch_time": instance.get('LaunchTime')
-                        })
-            
+                for reservation in response.get("Reservations", []):
+                    for instance in reservation.get("Instances", []):
+                        resources.append(
+                            {
+                                "resource_id": instance.get("InstanceId"),
+                                "resource_type": "EC2Instance",
+                                "region": region,
+                                "state": instance.get("State", {}).get("Name"),
+                                "instance_type": instance.get("InstanceType"),
+                                "tags": {tag["Key"]: tag["Value"] for tag in instance.get("Tags", [])},
+                                "launch_time": instance.get("LaunchTime"),
+                            }
+                        )
+
             elif service_type == "EBS":
-                ec2_client = self.session.client('ec2', region_name=region)
+                ec2_client = self.session.client("ec2", region_name=region)
                 response = ec2_client.describe_volumes()
-                for volume in response.get('Volumes', []):
-                    resources.append({
-                        "resource_id": volume.get('VolumeId'),
-                        "resource_type": "EBSVolume",
-                        "region": region,
-                        "state": volume.get('State'),
-                        "volume_type": volume.get('VolumeType'),
-                        "size": volume.get('Size'),
-                        "tags": {tag['Key']: tag['Value'] for tag in volume.get('Tags', [])},
-                        "attachments": volume.get('Attachments', [])
-                    })
-            
+                for volume in response.get("Volumes", []):
+                    resources.append(
+                        {
+                            "resource_id": volume.get("VolumeId"),
+                            "resource_type": "EBSVolume",
+                            "region": region,
+                            "state": volume.get("State"),
+                            "volume_type": volume.get("VolumeType"),
+                            "size": volume.get("Size"),
+                            "tags": {tag["Key"]: tag["Value"] for tag in volume.get("Tags", [])},
+                            "attachments": volume.get("Attachments", []),
+                        }
+                    )
+
             elif service_type == "RDS":
-                rds_client = self.session.client('rds', region_name=region)
+                rds_client = self.session.client("rds", region_name=region)
                 response = rds_client.describe_db_instances()
-                for db_instance in response.get('DBInstances', []):
-                    resources.append({
-                        "resource_id": db_instance.get('DBInstanceIdentifier'),
-                        "resource_type": "RDSInstance",
-                        "region": region,
-                        "status": db_instance.get('DBInstanceStatus'),
-                        "instance_class": db_instance.get('DBInstanceClass'),
-                        "engine": db_instance.get('Engine'),
-                        "allocated_storage": db_instance.get('AllocatedStorage'),
-                        "tags": []  # RDS tags require separate API call
-                    })
-            
+                for db_instance in response.get("DBInstances", []):
+                    resources.append(
+                        {
+                            "resource_id": db_instance.get("DBInstanceIdentifier"),
+                            "resource_type": "RDSInstance",
+                            "region": region,
+                            "status": db_instance.get("DBInstanceStatus"),
+                            "instance_class": db_instance.get("DBInstanceClass"),
+                            "engine": db_instance.get("Engine"),
+                            "allocated_storage": db_instance.get("AllocatedStorage"),
+                            "tags": [],  # RDS tags require separate API call
+                        }
+                    )
+
             elif service_type == "S3":
-                s3_client = self.session.client('s3')
+                s3_client = self.session.client("s3")
                 response = s3_client.list_buckets()
-                for bucket in response.get('Buckets', []):
+                for bucket in response.get("Buckets", []):
                     # Get bucket region
                     try:
-                        bucket_region = s3_client.get_bucket_location(
-                            Bucket=bucket['Name']
-                        ).get('LocationConstraint') or 'us-east-1'
-                        
-                        if bucket_region == region or region == 'us-east-1':
-                            resources.append({
-                                "resource_id": bucket['Name'],
-                                "resource_type": "S3Bucket",
-                                "region": bucket_region,
-                                "creation_date": bucket.get('CreationDate'),
-                                "tags": {}  # S3 tags require separate API call
-                            })
+                        bucket_region = (
+                            s3_client.get_bucket_location(Bucket=bucket["Name"]).get("LocationConstraint")
+                            or "us-east-1"
+                        )
+
+                        if bucket_region == region or region == "us-east-1":
+                            resources.append(
+                                {
+                                    "resource_id": bucket["Name"],
+                                    "resource_type": "S3Bucket",
+                                    "region": bucket_region,
+                                    "creation_date": bucket.get("CreationDate"),
+                                    "tags": {},  # S3 tags require separate API call
+                                }
+                            )
                     except ClientError:
                         # Bucket region access denied - skip
                         pass
-            
+
             elif service_type == "Lambda":
-                lambda_client = self.session.client('lambda', region_name=region)
+                lambda_client = self.session.client("lambda", region_name=region)
                 response = lambda_client.list_functions()
-                for function in response.get('Functions', []):
-                    resources.append({
-                        "resource_id": function.get('FunctionName'),
-                        "resource_type": "LambdaFunction",
-                        "region": region,
-                        "runtime": function.get('Runtime'),
-                        "memory_size": function.get('MemorySize'),
-                        "timeout": function.get('Timeout'),
-                        "last_modified": function.get('LastModified'),
-                        "tags": {}  # Lambda tags require separate API call
-                    })
-            
+                for function in response.get("Functions", []):
+                    resources.append(
+                        {
+                            "resource_id": function.get("FunctionName"),
+                            "resource_type": "LambdaFunction",
+                            "region": region,
+                            "runtime": function.get("Runtime"),
+                            "memory_size": function.get("MemorySize"),
+                            "timeout": function.get("Timeout"),
+                            "last_modified": function.get("LastModified"),
+                            "tags": {},  # Lambda tags require separate API call
+                        }
+                    )
+
             elif service_type == "IAM":
                 # IAM is global service - only process in us-east-1
-                if region == 'us-east-1':
-                    iam_client = self.session.client('iam')
+                if region == "us-east-1":
+                    iam_client = self.session.client("iam")
                     response = iam_client.list_users()
-                    for user in response.get('Users', []):
-                        resources.append({
-                            "resource_id": user.get('UserName'),
-                            "resource_type": "IAMUser",
-                            "region": "global",
-                            "path": user.get('Path'),
-                            "create_date": user.get('CreateDate'),
-                            "tags": []  # IAM tags require separate API call
-                        })
-        
+                    for user in response.get("Users", []):
+                        resources.append(
+                            {
+                                "resource_id": user.get("UserName"),
+                                "resource_type": "IAMUser",
+                                "region": "global",
+                                "path": user.get("Path"),
+                                "create_date": user.get("CreateDate"),
+                                "tags": [],  # IAM tags require separate API call
+                            }
+                        )
+
         except ClientError as e:
             print_warning(f"Service {service_type} in {region}: {e.response['Error']['Code']}")
         except Exception as e:
             print_error(f"Service {service_type} in {region}: {str(e)}")
-        
+
         return resources
-    
-    async def _analyze_optimization_opportunities(self, resources: Dict[str, List[Dict[str, Any]]],
-                                                optimization_focus: OptimizationCategory,
-                                                progress, task_id) -> List[Dict[str, Any]]:
+
+    async def _analyze_optimization_opportunities(
+        self, resources: Dict[str, List[Dict[str, Any]]], optimization_focus: OptimizationCategory, progress, task_id
+    ) -> List[Dict[str, Any]]:
         """Analyze optimization opportunities across discovered resources."""
         opportunities = []
-        
+
         for service_type, service_resources in resources.items():
             try:
                 # Apply optimization pattern matching
                 for pattern in self.automation_patterns:
                     if optimization_focus and pattern.category != optimization_focus:
                         continue
-                    
+
                     if any(service in pattern.aws_services for service in [service_type]):
                         # Pattern matches - analyze resources for optimization
                         service_opportunities = await self._analyze_service_optimization(
                             service_type, service_resources, pattern
                         )
                         opportunities.extend(service_opportunities)
-                
+
             except Exception as e:
                 print_warning(f"Optimization analysis failed for {service_type}: {str(e)}")
-            
+
             progress.advance(task_id)
-        
+
         return opportunities
-    
-    async def _analyze_service_optimization(self, service_type: str, 
-                                          resources: List[Dict[str, Any]],
-                                          pattern: AutomationPattern) -> List[Dict[str, Any]]:
+
+    async def _analyze_service_optimization(
+        self, service_type: str, resources: List[Dict[str, Any]], pattern: AutomationPattern
+    ) -> List[Dict[str, Any]]:
         """Analyze optimization opportunities for specific service type."""
         opportunities = []
-        
+
         for resource in resources:
             try:
                 optimization_opportunity = {
@@ -422,22 +465,22 @@ class UniversalAutomationEngine:
                     "potential_annual_savings": pattern.annual_savings_potential,
                     "recommended_action": self._get_recommended_action(resource, pattern),
                     "implementation_complexity": pattern.technical_complexity,
-                    "safety_score": self._calculate_safety_score(resource, pattern)
+                    "safety_score": self._calculate_safety_score(resource, pattern),
                 }
-                
+
                 # Only include if there's actual optimization potential
                 if optimization_opportunity["recommended_action"] != "no_action":
                     opportunities.append(optimization_opportunity)
-                    
+
             except Exception as e:
                 logger.warning(f"Optimization analysis failed for resource {resource.get('resource_id')}: {e}")
-        
+
         return opportunities
-    
+
     def _get_recommended_action(self, resource: Dict[str, Any], pattern: AutomationPattern) -> str:
         """Get recommended optimization action for resource."""
         resource_type = resource.get("resource_type")
-        
+
         # Cost optimization recommendations
         if pattern.category == OptimizationCategory.COST_OPTIMIZATION:
             if resource_type == "EC2Instance":
@@ -446,175 +489,170 @@ class UniversalAutomationEngine:
                 elif not resource.get("tags"):
                     return "evaluate_untagged_instance"
                 return "evaluate_rightsizing"
-            
+
             elif resource_type == "EBSVolume":
                 if not resource.get("attachments"):
                     return "delete_unattached_volume"
                 elif resource.get("volume_type") == "gp2":
                     return "convert_gp2_to_gp3"
                 return "evaluate_volume_usage"
-            
+
             elif resource_type == "RDSInstance":
                 if resource.get("status") == "stopped":
                     return "evaluate_idle_database"
                 return "evaluate_instance_class"
-        
+
         # Security optimization recommendations
         elif pattern.category == OptimizationCategory.SECURITY_COMPLIANCE:
             if resource_type == "IAMUser":
                 return "audit_access_keys"
             elif resource_type == "S3Bucket":
                 return "audit_bucket_permissions"
-        
+
         return "no_action"
-    
+
     def _calculate_safety_score(self, resource: Dict[str, Any], pattern: AutomationPattern) -> float:
         """Calculate safety score for optimization action (0.0 = high risk, 1.0 = safe)."""
         base_score = 0.7  # Conservative baseline
-        
+
         # Increase safety for resources with proper tagging
         if resource.get("tags"):
             base_score += 0.2
-        
+
         # Decrease safety for running/active resources
         if resource.get("state") == "running" or resource.get("status") == "available":
             base_score -= 0.1
-        
+
         # Pattern-specific adjustments
         if pattern.category == OptimizationCategory.COST_OPTIMIZATION:
             if "delete" in self._get_recommended_action(resource, pattern):
                 base_score -= 0.2  # Deletion is higher risk
-        
+
         return max(0.0, min(1.0, base_score))  # Clamp between 0.0 and 1.0
-    
-    async def _calculate_business_impact(self, opportunities: List[Dict[str, Any]], 
-                                       progress, task_id) -> Dict[str, Any]:
+
+    async def _calculate_business_impact(
+        self, opportunities: List[Dict[str, Any]], progress, task_id
+    ) -> Dict[str, Any]:
         """Calculate comprehensive business impact from optimization opportunities."""
         total_potential_savings = 0.0
         impact_by_category = {}
         high_impact_opportunities = 0
-        
+
         for opportunity in opportunities:
             # Calculate potential savings (take conservative estimate)
             min_savings, max_savings = opportunity["potential_annual_savings"]
             conservative_savings = min_savings * 0.3  # 30% of minimum estimate
             total_potential_savings += conservative_savings
-            
+
             # Categorize impact
             category = opportunity["category"]
             if category not in impact_by_category:
-                impact_by_category[category] = {
-                    "count": 0,
-                    "potential_savings": 0.0,
-                    "high_impact_count": 0
-                }
-            
+                impact_by_category[category] = {"count": 0, "potential_savings": 0.0, "high_impact_count": 0}
+
             impact_by_category[category]["count"] += 1
             impact_by_category[category]["potential_savings"] += conservative_savings
-            
+
             if opportunity["business_impact"] == "high":
                 high_impact_opportunities += 1
                 impact_by_category[category]["high_impact_count"] += 1
-        
+
         progress.advance(task_id)
-        
+
         return {
             "total_opportunities": len(opportunities),
             "high_impact_opportunities": high_impact_opportunities,
             "total_potential_annual_savings": total_potential_savings,
             "impact_by_category": impact_by_category,
-            "roi_timeline_months": 3 if total_potential_savings > 100_000 else 6
+            "roi_timeline_months": 3 if total_potential_savings > 100_000 else 6,
         }
-    
+
     def _display_discovery_summary(self, results: Dict[str, Any]) -> None:
         """Display executive summary of universal resource discovery."""
-        
+
         # Executive Summary Panel
         business_impact = results["business_impact"]
         summary_content = f"""
 🌐 Universal Resource Discovery Results
 
 📊 Infrastructure Analysis:
-   • Total Resources Discovered: {results['total_resources_discovered']:,}
-   • Services Analyzed: {', '.join(results['services_analyzed'])}
-   • Regions Covered: {', '.join(results['regions_covered'])}
-   • Optimization Opportunities: {business_impact['total_opportunities']:,}
+   • Total Resources Discovered: {results["total_resources_discovered"]:,}
+   • Services Analyzed: {", ".join(results["services_analyzed"])}
+   • Regions Covered: {", ".join(results["regions_covered"])}
+   • Optimization Opportunities: {business_impact["total_opportunities"]:,}
 
 💰 Business Impact Analysis:
-   • High-Impact Opportunities: {business_impact['high_impact_opportunities']:,}
-   • Total Potential Annual Savings: {format_cost(business_impact['total_potential_annual_savings'])}
-   • ROI Timeline: {business_impact['roi_timeline_months']} months
-   • Analysis Execution Time: {results['execution_time_seconds']:.2f}s
+   • High-Impact Opportunities: {business_impact["high_impact_opportunities"]:,}
+   • Total Potential Annual Savings: {format_cost(business_impact["total_potential_annual_savings"])}
+   • ROI Timeline: {business_impact["roi_timeline_months"]} months
+   • Analysis Execution Time: {results["execution_time_seconds"]:.2f}s
 
 🎯 Strategic Recommendations:
    • Priority Focus: Cost optimization opportunities with immediate impact
    • Implementation Approach: Systematic automation using consolidated patterns
    • Safety Controls: Enterprise approval workflows with audit trails
         """
-        
-        console.print(create_panel(
-            summary_content.strip(),
-            title="🏆 Universal Resource Discovery Executive Summary",
-            border_style="green"
-        ))
-        
+
+        console.print(
+            create_panel(
+                summary_content.strip(), title="🏆 Universal Resource Discovery Executive Summary", border_style="green"
+            )
+        )
+
         # Category Breakdown Table
         if business_impact["impact_by_category"]:
-            table = create_table(
-                title="Optimization Opportunities by Category"
-            )
-            
+            table = create_table(title="Optimization Opportunities by Category")
+
             table.add_column("Category", style="cyan", no_wrap=True)
             table.add_column("Opportunities", justify="center")
             table.add_column("High Impact", justify="center", style="red")
             table.add_column("Potential Savings", justify="right", style="green")
             table.add_column("Implementation", justify="center", style="dim")
-            
+
             for category, impact_data in business_impact["impact_by_category"].items():
                 category_display = category.replace("_", " ").title()
-                
+
                 table.add_row(
                     category_display,
                     str(impact_data["count"]),
                     str(impact_data["high_impact_count"]),
                     format_cost(impact_data["potential_savings"]),
-                    "2-4 weeks"
+                    "2-4 weeks",
                 )
-            
+
             console.print(table)
-    
+
     async def validate_with_mcp(self, results: Dict[str, Any]) -> float:
         """Validate discovery results with embedded MCP validator."""
         try:
             # Prepare validation data in FinOps format
             validation_data = {
-                'total_opportunities': results["business_impact"]["total_opportunities"],
-                'potential_annual_savings': results["business_impact"]["total_potential_annual_savings"],
-                'resources_analyzed': results["total_resources_discovered"],
-                'services_covered': results["services_analyzed"],
-                'analysis_timestamp': results["analysis_timestamp"].isoformat()
+                "total_opportunities": results["business_impact"]["total_opportunities"],
+                "potential_annual_savings": results["business_impact"]["total_potential_annual_savings"],
+                "resources_analyzed": results["total_resources_discovered"],
+                "services_covered": results["services_analyzed"],
+                "analysis_timestamp": results["analysis_timestamp"].isoformat(),
             }
-            
+
             # Initialize MCP validator if profile is available
             if self.profile_name:
                 mcp_validator = EmbeddedMCPValidator([self.profile_name])
                 validation_results = await mcp_validator.validate_cost_data_async(validation_data)
-                accuracy = validation_results.get('total_accuracy', 0.0)
-                
+                accuracy = validation_results.get("total_accuracy", 0.0)
+
                 if accuracy >= 99.5:
                     print_success(f"MCP Validation: {accuracy:.1f}% accuracy achieved (target: ≥99.5%)")
                 else:
                     print_warning(f"MCP Validation: {accuracy:.1f}% accuracy (target: ≥99.5%)")
-                    
+
                 return accuracy
             else:
                 print_info("MCP validation skipped - no profile specified")
                 return 0.0
-                
+
         except Exception as e:
             print_warning(f"MCP validation failed: {str(e)}")
             return 0.0
-    
+
     def get_automation_patterns(self, category: OptimizationCategory = None) -> List[AutomationPattern]:
         """Get automation patterns, optionally filtered by category."""
         if category:
@@ -628,16 +666,15 @@ def get_universal_automation_engine(profile: str = None, regions: List[str] = No
     return UniversalAutomationEngine(profile_name=profile, regions=regions)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Test universal automation engine
     import asyncio
-    
+
     async def test_discovery():
         engine = UniversalAutomationEngine()
         results = await engine.discover_resources_universal(
-            service_types=["EC2", "EBS"],
-            optimization_focus=OptimizationCategory.COST_OPTIMIZATION
+            service_types=["EC2", "EBS"], optimization_focus=OptimizationCategory.COST_OPTIMIZATION
         )
         print(f"Discovery completed: {results['total_resources_discovered']} resources analyzed")
-    
-    asyncio.run(test_discovery())
+
+    asyncio.run(test_discovery())