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

runbooks/finops/elastic_ip_optimizer.py

@@ -1,14 +1,14 @@
 #!/usr/bin/env python3
 """
 Elastic IP Resource Efficiency Analyzer - Enterprise FinOps Analysis Platform
-Strategic Business Focus: Elastic IP resource efficiency optimization for Manager, Financial, and CTO stakeholders  
+Strategic Business Focus: Elastic IP resource efficiency optimization for Manager, Financial, and CTO stakeholders
 
 Strategic Achievement: Part of $132,720+ annual savings methodology (380-757% ROI achievement)
 Business Impact: $1.8M-$3.1M annual savings potential across enterprise accounts
 Technical Foundation: Enterprise-grade Elastic IP discovery and attachment validation
 
 This module provides comprehensive Elastic IP resource efficiency analysis following proven FinOps patterns:
-- Multi-region Elastic IP discovery across all AWS regions  
+- Multi-region Elastic IP discovery across all AWS regions
 - Instance attachment validation and DNS dependency checking
 - Cost savings calculation ($3.65/month per unattached EIP)
 - Safety analysis (ensure EIPs aren't referenced in DNS, load balancers, etc.)
@@ -16,7 +16,7 @@ This module provides comprehensive Elastic IP resource efficiency analysis follo
 
 Strategic Alignment:
 - "Do one thing and do it well": Elastic IP resource efficiency specialization
-- "Move Fast, But Not So Fast We Crash": Safety-first analysis approach  
+- "Move Fast, But Not So Fast We Crash": Safety-first analysis approach
 - Enterprise FAANG SDLC: Evidence-based optimization with audit trails
 - Universal $132K Cost Optimization Methodology: Manager scenarios prioritized over generic patterns
 """
@@ -32,19 +32,29 @@ import click
 from botocore.exceptions import ClientError, NoCredentialsError
 from pydantic import BaseModel, Field
 
+from ..common.aws_pricing import calculate_annual_cost, get_service_monthly_cost
+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 ..common.aws_pricing import get_service_monthly_cost, calculate_annual_cost
-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 ElasticIPDetails(BaseModel):
     """Elastic IP details from EC2 API."""
+
     allocation_id: str
     public_ip: str
     region: str
@@ -60,6 +70,7 @@ class ElasticIPDetails(BaseModel):
 
 class ElasticIPOptimizationResult(BaseModel):
     """Elastic IP optimization analysis results."""
+
     allocation_id: str
     public_ip: str
     region: str
@@ -67,7 +78,7 @@ class ElasticIPOptimizationResult(BaseModel):
     is_attached: bool
     instance_id: Optional[str] = None
     monthly_cost: float = 0.0  # Calculated dynamically per region
-    annual_cost: float = 0.0   # Calculated dynamically (monthly * 12)
+    annual_cost: float = 0.0  # Calculated dynamically (monthly * 12)
     optimization_recommendation: str = "retain"  # retain, release
     risk_level: str = "low"  # low, medium, high
     business_impact: str = "minimal"
@@ -79,6 +90,7 @@ class ElasticIPOptimizationResult(BaseModel):
 
 class ElasticIPOptimizerResults(BaseModel):
     """Complete Elastic IP optimization analysis results."""
+
     total_elastic_ips: int = 0
     attached_elastic_ips: int = 0
     unattached_elastic_ips: int = 0
@@ -96,7 +108,7 @@ class ElasticIPOptimizerResults(BaseModel):
 class ElasticIPOptimizer:
     """
     Elastic IP Resource Efficiency Analyzer - Enterprise FinOps Analysis Engine
-    
+
     Following $132,720+ methodology with proven FinOps patterns targeting $1.8M-$3.1M annual savings:
     - Multi-region discovery and analysis across enterprise accounts
     - Instance attachment validation with safety controls
@@ -105,92 +117,111 @@ class ElasticIPOptimizer:
     - Evidence generation for Manager/Financial/CTO executive reporting
     - Business-focused naming for executive presentation readiness
     """
-    
+
     def __init__(self, profile_name: Optional[str] = None, regions: Optional[List[str]] = None):
         """Initialize Elastic IP optimizer 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))
+
         # Dynamic Elastic IP pricing - Enterprise compliance (no hardcoded values)
         # Pricing will be calculated dynamically per region using AWS Pricing API
-        
+
         # 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",
         ]
-        
+
     async def analyze_elastic_ips(self, dry_run: bool = True) -> ElasticIPOptimizerResults:
         """
         Comprehensive Elastic IP cost optimization analysis.
-        
+
         Args:
             dry_run: Safety mode - READ-ONLY analysis only
-            
+
         Returns:
             Complete analysis results with optimization recommendations
         """
         print_header("Elastic IP Resource Efficiency Analyzer", "Enterprise FinOps Analysis Platform v1.0")
-        
+
         if not dry_run:
             print_warning("⚠️ Dry-run disabled - This optimizer is READ-ONLY analysis only")
             print_info("All Elastic IP operations require manual execution after review")
-        
+
         analysis_start_time = time.time()
-        
+
         try:
             with create_progress_bar() as progress:
                 # Step 1: Multi-region Elastic IP discovery
                 discovery_task = progress.add_task("Discovering Elastic IPs...", total=len(self.regions))
                 elastic_ips = await self._discover_elastic_ips_multi_region(progress, discovery_task)
-                
+
                 if not elastic_ips:
                     print_warning("No Elastic IPs found in specified regions")
                     return ElasticIPOptimizerResults(
                         analyzed_regions=self.regions,
                         analysis_timestamp=datetime.now(),
-                        execution_time_seconds=time.time() - analysis_start_time
+                        execution_time_seconds=time.time() - analysis_start_time,
                     )
-                
-                # Step 2: Attachment validation analysis  
+
+                # Step 2: Attachment validation analysis
                 attachment_task = progress.add_task("Validating attachments...", total=len(elastic_ips))
                 validated_elastic_ips = await self._validate_attachments(elastic_ips, progress, attachment_task)
-                
+
                 # Step 3: DNS dependency analysis for safety
                 dns_task = progress.add_task("Checking DNS dependencies...", total=len(elastic_ips))
                 dns_dependencies = await self._analyze_dns_dependencies(validated_elastic_ips, progress, dns_task)
-                
+
                 # Step 4: Cost optimization analysis
                 optimization_task = progress.add_task("Calculating optimization potential...", total=len(elastic_ips))
                 optimization_results = await self._calculate_optimization_recommendations(
                     validated_elastic_ips, dns_dependencies, progress, optimization_task
                 )
-                
+
                 # Step 5: MCP validation
                 validation_task = progress.add_task("MCP validation...", total=1)
                 mcp_accuracy = await self._validate_with_mcp(optimization_results, progress, validation_task)
-                
+
             # Compile comprehensive results
             attached_count = sum(1 for result in optimization_results if result.is_attached)
             unattached_count = len(optimization_results) - attached_count
-            
+
             total_monthly_cost = sum(result.monthly_cost for result in optimization_results if not result.is_attached)
             total_annual_cost = total_monthly_cost * 12
             potential_monthly_savings = sum(result.potential_monthly_savings for result in optimization_results)
             potential_annual_savings = potential_monthly_savings * 12
-            
+
             results = ElasticIPOptimizerResults(
                 total_elastic_ips=len(elastic_ips),
                 attached_elastic_ips=attached_count,
@@ -203,185 +234,195 @@ class ElasticIPOptimizer:
                 potential_annual_savings=potential_annual_savings,
                 execution_time_seconds=time.time() - analysis_start_time,
                 mcp_validation_accuracy=mcp_accuracy,
-                analysis_timestamp=datetime.now()
+                analysis_timestamp=datetime.now(),
             )
-            
+
             # Display executive summary
             self._display_executive_summary(results)
-            
+
             return results
-            
+
         except Exception as e:
             print_error(f"Elastic IP optimization analysis failed: {e}")
             logger.error(f"Elastic IP analysis error: {e}", exc_info=True)
             raise
-    
+
     async def _discover_elastic_ips_multi_region(self, progress, task_id) -> List[ElasticIPDetails]:
         """Discover Elastic IPs across multiple regions."""
         elastic_ips = []
-        
+
         for region in self.regions:
             try:
-                ec2_client = self.session.client('ec2', region_name=region)
-                
+                ec2_client = self.session.client("ec2", region_name=region)
+
                 # Get all Elastic IPs in region
                 response = ec2_client.describe_addresses()
-                
-                for address in response.get('Addresses', []):
+
+                for address in response.get("Addresses", []):
                     # Extract tags
-                    tags = {tag['Key']: tag['Value'] for tag in address.get('Tags', [])}
-                    
+                    tags = {tag["Key"]: tag["Value"] for tag in address.get("Tags", [])}
+
                     # Determine attachment status
-                    is_attached = 'AssociationId' in address
-                    
-                    elastic_ips.append(ElasticIPDetails(
-                        allocation_id=address['AllocationId'],
-                        public_ip=address['PublicIp'],
-                        region=region,
-                        domain=address.get('Domain', 'vpc'),
-                        instance_id=address.get('InstanceId'),
-                        association_id=address.get('AssociationId'),
-                        network_interface_id=address.get('NetworkInterfaceId'),
-                        network_interface_owner_id=address.get('NetworkInterfaceOwnerId'),
-                        private_ip_address=address.get('PrivateIpAddress'),
-                        tags=tags,
-                        is_attached=is_attached
-                    ))
-                    
-                print_info(f"Region {region}: {len([eip for eip in elastic_ips if eip.region == region])} Elastic IPs discovered")
-                
+                    is_attached = "AssociationId" in address
+
+                    elastic_ips.append(
+                        ElasticIPDetails(
+                            allocation_id=address["AllocationId"],
+                            public_ip=address["PublicIp"],
+                            region=region,
+                            domain=address.get("Domain", "vpc"),
+                            instance_id=address.get("InstanceId"),
+                            association_id=address.get("AssociationId"),
+                            network_interface_id=address.get("NetworkInterfaceId"),
+                            network_interface_owner_id=address.get("NetworkInterfaceOwnerId"),
+                            private_ip_address=address.get("PrivateIpAddress"),
+                            tags=tags,
+                            is_attached=is_attached,
+                        )
+                    )
+
+                print_info(
+                    f"Region {region}: {len([eip for eip in elastic_ips if eip.region == region])} Elastic IPs 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 elastic_ips
-    
-    async def _validate_attachments(self, elastic_ips: List[ElasticIPDetails], progress, task_id) -> List[ElasticIPDetails]:
+
+    async def _validate_attachments(
+        self, elastic_ips: List[ElasticIPDetails], progress, task_id
+    ) -> List[ElasticIPDetails]:
         """Validate Elastic IP attachments and instance details."""
         validated_ips = []
-        
+
         for elastic_ip in elastic_ips:
             try:
                 # Additional validation for attached EIPs
                 if elastic_ip.is_attached and elastic_ip.instance_id:
-                    ec2_client = self.session.client('ec2', region_name=elastic_ip.region)
-                    
+                    ec2_client = self.session.client("ec2", region_name=elastic_ip.region)
+
                     # Verify instance still exists and is running
                     try:
                         response = ec2_client.describe_instances(InstanceIds=[elastic_ip.instance_id])
-                        instance_found = len(response.get('Reservations', [])) > 0
-                        
+                        instance_found = len(response.get("Reservations", [])) > 0
+
                         if instance_found:
-                            instance = response['Reservations'][0]['Instances'][0]
-                            elastic_ip.is_attached = instance['State']['Name'] in ['running', 'stopped', 'stopping', 'starting']
+                            instance = response["Reservations"][0]["Instances"][0]
+                            elastic_ip.is_attached = instance["State"]["Name"] in [
+                                "running",
+                                "stopped",
+                                "stopping",
+                                "starting",
+                            ]
                         else:
                             elastic_ip.is_attached = False
-                            
+
                     except ClientError:
                         # Instance not found - EIP is effectively unattached
                         elastic_ip.is_attached = False
-                
+
                 validated_ips.append(elastic_ip)
-                
+
             except Exception as e:
                 print_warning(f"Validation failed for {elastic_ip.public_ip}: {str(e)}")
                 validated_ips.append(elastic_ip)  # Add with original status
-                
+
             progress.advance(task_id)
-        
+
         return validated_ips
-    
-    async def _analyze_dns_dependencies(self, elastic_ips: List[ElasticIPDetails], progress, task_id) -> Dict[str, List[str]]:
+
+    async def _analyze_dns_dependencies(
+        self, elastic_ips: List[ElasticIPDetails], progress, task_id
+    ) -> Dict[str, List[str]]:
         """Analyze potential DNS dependencies for Elastic IPs."""
         dns_dependencies = {}
-        
+
         for elastic_ip in elastic_ips:
             try:
                 dns_refs = []
-                
+
                 # Check Route 53 hosted zones for this IP
                 try:
-                    route53_client = self.session.client('route53')
+                    route53_client = self.session.client("route53")
                     hosted_zones = route53_client.list_hosted_zones()
-                    
-                    for zone in hosted_zones.get('HostedZones', []):
+
+                    for zone in hosted_zones.get("HostedZones", []):
                         try:
-                            records = route53_client.list_resource_record_sets(
-                                HostedZoneId=zone['Id']
-                            )
-                            
-                            for record in records.get('ResourceRecordSets', []):
-                                if record['Type'] == 'A':
-                                    for resource_record in record.get('ResourceRecords', []):
-                                        if resource_record.get('Value') == elastic_ip.public_ip:
+                            records = route53_client.list_resource_record_sets(HostedZoneId=zone["Id"])
+
+                            for record in records.get("ResourceRecordSets", []):
+                                if record["Type"] == "A":
+                                    for resource_record in record.get("ResourceRecords", []):
+                                        if resource_record.get("Value") == elastic_ip.public_ip:
                                             dns_refs.append(f"Route53: {record['Name']} -> {elastic_ip.public_ip}")
-                                            
+
                         except ClientError:
                             # Zone not accessible or other error - continue
                             pass
-                            
+
                 except ClientError:
                     # Route 53 not accessible - skip DNS check
                     pass
-                
+
                 # Check Application Load Balancers (ALB)
                 try:
-                    elbv2_client = self.session.client('elbv2', region_name=elastic_ip.region)
+                    elbv2_client = self.session.client("elbv2", region_name=elastic_ip.region)
                     load_balancers = elbv2_client.describe_load_balancers()
-                    
-                    for lb in load_balancers.get('LoadBalancers', []):
-                        if elastic_ip.public_ip in lb.get('CanonicalHostedZoneId', ''):
+
+                    for lb in load_balancers.get("LoadBalancers", []):
+                        if elastic_ip.public_ip in lb.get("CanonicalHostedZoneId", ""):
                             dns_refs.append(f"ALB: {lb['LoadBalancerName']} references EIP")
-                            
+
                 except ClientError:
                     # ELB not accessible - skip check
                     pass
-                
+
                 dns_dependencies[elastic_ip.allocation_id] = dns_refs
-                
+
             except Exception as e:
                 print_warning(f"DNS analysis failed for {elastic_ip.public_ip}: {str(e)}")
                 dns_dependencies[elastic_ip.allocation_id] = []
-                
+
             progress.advance(task_id)
-        
+
         return dns_dependencies
-    
-    async def _calculate_optimization_recommendations(self, 
-                                                    elastic_ips: List[ElasticIPDetails],
-                                                    dns_dependencies: Dict[str, List[str]],
-                                                    progress, task_id) -> List[ElasticIPOptimizationResult]:
+
+    async def _calculate_optimization_recommendations(
+        self, elastic_ips: List[ElasticIPDetails], dns_dependencies: Dict[str, List[str]], progress, task_id
+    ) -> List[ElasticIPOptimizationResult]:
         """Calculate optimization recommendations and potential savings."""
         optimization_results = []
-        
+
         for elastic_ip in elastic_ips:
             try:
                 dns_refs = dns_dependencies.get(elastic_ip.allocation_id, [])
-                
+
                 # Calculate current costs (only unattached EIPs are charged) - Dynamic pricing
                 if elastic_ip.is_attached:
                     monthly_cost = 0.0  # Attached EIPs are free
                 else:
                     monthly_cost = get_service_monthly_cost("elastic_ip", elastic_ip.region)
                 annual_cost = calculate_annual_cost(monthly_cost)
-                
+
                 # Determine optimization recommendation
                 recommendation = "retain"  # Default: keep the Elastic IP
                 risk_level = "low"
                 business_impact = "minimal"
                 potential_monthly_savings = 0.0
-                
+
                 # Safety checks
                 safety_checks = {
                     "is_unattached": not elastic_ip.is_attached,
                     "no_dns_references": len(dns_refs) == 0,
                     "no_instance_dependency": elastic_ip.instance_id is None,
-                    "safe_to_release": False
+                    "safe_to_release": False,
                 }
-                
+
                 if not elastic_ip.is_attached:
                     if not dns_refs:
                         # Unattached with no DNS references - safe to release
@@ -402,71 +443,74 @@ class ElasticIPOptimizer:
                     risk_level = "low"
                     business_impact = "none"
                     potential_monthly_savings = 0.0
-                
-                optimization_results.append(ElasticIPOptimizationResult(
-                    allocation_id=elastic_ip.allocation_id,
-                    public_ip=elastic_ip.public_ip,
-                    region=elastic_ip.region,
-                    domain=elastic_ip.domain,
-                    is_attached=elastic_ip.is_attached,
-                    instance_id=elastic_ip.instance_id,
-                    monthly_cost=monthly_cost,
-                    annual_cost=annual_cost,
-                    optimization_recommendation=recommendation,
-                    risk_level=risk_level,
-                    business_impact=business_impact,
-                    potential_monthly_savings=potential_monthly_savings,
-                    potential_annual_savings=potential_monthly_savings * 12,
-                    safety_checks=safety_checks,
-                    dns_references=dns_refs
-                ))
-                
+
+                optimization_results.append(
+                    ElasticIPOptimizationResult(
+                        allocation_id=elastic_ip.allocation_id,
+                        public_ip=elastic_ip.public_ip,
+                        region=elastic_ip.region,
+                        domain=elastic_ip.domain,
+                        is_attached=elastic_ip.is_attached,
+                        instance_id=elastic_ip.instance_id,
+                        monthly_cost=monthly_cost,
+                        annual_cost=annual_cost,
+                        optimization_recommendation=recommendation,
+                        risk_level=risk_level,
+                        business_impact=business_impact,
+                        potential_monthly_savings=potential_monthly_savings,
+                        potential_annual_savings=potential_monthly_savings * 12,
+                        safety_checks=safety_checks,
+                        dns_references=dns_refs,
+                    )
+                )
+
             except Exception as e:
                 print_error(f"Optimization calculation failed for {elastic_ip.public_ip}: {str(e)}")
-                
+
             progress.advance(task_id)
-        
+
         return optimization_results
-    
-    async def _validate_with_mcp(self, optimization_results: List[ElasticIPOptimizationResult], 
-                               progress, task_id) -> float:
+
+    async def _validate_with_mcp(
+        self, optimization_results: List[ElasticIPOptimizationResult], progress, task_id
+    ) -> float:
         """Validate optimization results with embedded MCP validator."""
         try:
             # Prepare validation data in FinOps format
             validation_data = {
-                'total_annual_cost': sum(result.annual_cost for result in optimization_results),
-                'potential_annual_savings': sum(result.potential_annual_savings for result in optimization_results),
-                'elastic_ips_analyzed': len(optimization_results),
-                'regions_analyzed': list(set(result.region for result in optimization_results)),
-                'analysis_timestamp': datetime.now().isoformat()
+                "total_annual_cost": sum(result.annual_cost for result in optimization_results),
+                "potential_annual_savings": sum(result.potential_annual_savings for result in optimization_results),
+                "elastic_ips_analyzed": len(optimization_results),
+                "regions_analyzed": list(set(result.region for result in optimization_results)),
+                "analysis_timestamp": datetime.now().isoformat(),
             }
-            
+
             # Initialize MCP validator if profile is available
             if self.profile_name:
                 mcp_validator = EmbeddedMCPValidator([self.profile_name])
                 validation_results = await mcp_validator.validate_cost_data_async(validation_data)
-                accuracy = validation_results.get('total_accuracy', 0.0)
-                
+                accuracy = validation_results.get("total_accuracy", 0.0)
+
                 if accuracy >= 99.5:
                     print_success(f"MCP Validation: {accuracy:.1f}% accuracy achieved (target: ≥99.5%)")
                 else:
                     print_warning(f"MCP Validation: {accuracy:.1f}% accuracy (target: ≥99.5%)")
-                    
+
                 progress.advance(task_id)
                 return accuracy
             else:
                 print_info("MCP validation skipped - no profile specified")
                 progress.advance(task_id)
                 return 0.0
-                
+
         except Exception as e:
             print_warning(f"MCP validation failed: {str(e)}")
             progress.advance(task_id)
             return 0.0
-    
+
     def _display_executive_summary(self, results: ElasticIPOptimizerResults) -> None:
         """Display executive summary with Rich CLI formatting."""
-        
+
         # Executive Summary Panel
         summary_content = f"""
 💰 Total Annual Cost: {format_cost(results.total_annual_cost)}
@@ -474,22 +518,22 @@ class ElasticIPOptimizer:
 🎯 Elastic IPs Analyzed: {results.total_elastic_ips}
 📎 Attached EIPs: {results.attached_elastic_ips}
 🔓 Unattached EIPs: {results.unattached_elastic_ips}
-🌍 Regions: {', '.join(results.analyzed_regions)}
+🌍 Regions: {", ".join(results.analyzed_regions)}
 ⚡ Analysis Time: {results.execution_time_seconds:.2f}s
 ✅ MCP Accuracy: {results.mcp_validation_accuracy:.1f}%
         """
-        
-        console.print(create_panel(
-            summary_content.strip(),
-            title="🏆 Elastic IP Resource Efficiency Analysis Summary",
-            border_style="green"
-        ))
-        
-        # Detailed Results Table
-        table = create_table(
-            title="Elastic IP Optimization Recommendations"
+
+        console.print(
+            create_panel(
+                summary_content.strip(),
+                title="🏆 Elastic IP Resource Efficiency Analysis Summary",
+                border_style="green",
+            )
         )
-        
+
+        # Detailed Results Table
+        table = create_table(title="Elastic IP Optimization Recommendations")
+
         table.add_column("Elastic IP", style="cyan", no_wrap=True)
         table.add_column("Region", style="dim")
         table.add_column("Status", justify="center")
@@ -498,31 +542,21 @@ class ElasticIPOptimizer:
         table.add_column("Recommendation", justify="center")
         table.add_column("Risk Level", justify="center")
         table.add_column("DNS Refs", justify="center", style="dim")
-        
+
         # Sort by potential savings (descending)
-        sorted_results = sorted(
-            results.optimization_results, 
-            key=lambda x: x.potential_annual_savings, 
-            reverse=True
-        )
-        
+        sorted_results = sorted(results.optimization_results, key=lambda x: x.potential_annual_savings, reverse=True)
+
         for result in sorted_results:
             # Status indicators
             status_indicator = "🔗 Attached" if result.is_attached else "🔓 Unattached"
-            
+
             # Recommendation colors
-            rec_color = {
-                "release": "red",
-                "investigate": "yellow", 
-                "retain": "green"
-            }.get(result.optimization_recommendation, "white")
-            
-            risk_indicator = {
-                "low": "🟢",
-                "medium": "🟡", 
-                "high": "🔴"
-            }.get(result.risk_level, "⚪")
-            
+            rec_color = {"release": "red", "investigate": "yellow", "retain": "green"}.get(
+                result.optimization_recommendation, "white"
+            )
+
+            risk_indicator = {"low": "🟢", "medium": "🟡", "high": "🔴"}.get(result.risk_level, "⚪")
+
             table.add_row(
                 result.public_ip,
                 result.region,
@@ -531,11 +565,11 @@ class ElasticIPOptimizer:
                 format_cost(result.potential_annual_savings) if result.potential_annual_savings > 0 else "-",
                 f"[{rec_color}]{result.optimization_recommendation.title()}[/]",
                 f"{risk_indicator} {result.risk_level.title()}",
-                str(len(result.dns_references))
+                str(len(result.dns_references)),
             )
-        
+
         console.print(table)
-        
+
         # Optimization Summary by Recommendation
         if results.optimization_results:
             recommendations_summary = {}
@@ -545,64 +579,84 @@ class ElasticIPOptimizer:
                     recommendations_summary[rec] = {"count": 0, "savings": 0.0}
                 recommendations_summary[rec]["count"] += 1
                 recommendations_summary[rec]["savings"] += result.potential_annual_savings
-            
+
             rec_content = []
             for rec, data in recommendations_summary.items():
-                rec_content.append(f"• {rec.title()}: {data['count']} Elastic IPs ({format_cost(data['savings'])} potential savings)")
-            
-            console.print(create_panel(
-                "\n".join(rec_content),
-                title="📋 Recommendations Summary",
-                border_style="blue"
-            ))
-    
-    def export_results(self, results: ElasticIPOptimizerResults, 
-                      output_file: Optional[str] = None, 
-                      export_format: str = "json") -> str:
+                rec_content.append(
+                    f"• {rec.title()}: {data['count']} Elastic IPs ({format_cost(data['savings'])} potential savings)"
+                )
+
+            console.print(create_panel("\n".join(rec_content), title="📋 Recommendations Summary", border_style="blue"))
+
+    def export_results(
+        self, results: ElasticIPOptimizerResults, output_file: Optional[str] = None, export_format: str = "json"
+    ) -> str:
         """
         Export optimization results to various formats.
-        
+
         Args:
             results: Optimization analysis results
             output_file: Output file path (optional)
             export_format: Export format (json, csv, markdown)
-            
+
         Returns:
             Path to exported file
         """
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        
+
         if not output_file:
             output_file = f"elastic_ip_optimization_{timestamp}.{export_format}"
-        
+
         try:
             if export_format.lower() == "json":
                 import json
-                with open(output_file, 'w') as f:
+
+                with open(output_file, "w") as f:
                     json.dump(results.dict(), f, indent=2, default=str)
-                    
+
             elif export_format.lower() == "csv":
                 import csv
-                with open(output_file, 'w', newline='') as f:
+
+                with open(output_file, "w", newline="") as f:
                     writer = csv.writer(f)
-                    writer.writerow([
-                        'Allocation ID', 'Public IP', 'Region', 'Domain', 'Attached',
-                        'Instance ID', 'Monthly Cost', 'Annual Cost', 
-                        'Potential Monthly Savings', 'Potential Annual Savings',
-                        'Recommendation', 'Risk Level', 'DNS References'
-                    ])
+                    writer.writerow(
+                        [
+                            "Allocation ID",
+                            "Public IP",
+                            "Region",
+                            "Domain",
+                            "Attached",
+                            "Instance ID",
+                            "Monthly Cost",
+                            "Annual Cost",
+                            "Potential Monthly Savings",
+                            "Potential Annual Savings",
+                            "Recommendation",
+                            "Risk Level",
+                            "DNS References",
+                        ]
+                    )
                     for result in results.optimization_results:
-                        writer.writerow([
-                            result.allocation_id, result.public_ip, result.region, 
-                            result.domain, result.is_attached, result.instance_id or '',
-                            f"${result.monthly_cost:.2f}", f"${result.annual_cost:.2f}",
-                            f"${result.potential_monthly_savings:.2f}", f"${result.potential_annual_savings:.2f}",
-                            result.optimization_recommendation, result.risk_level,
-                            len(result.dns_references)
-                        ])
-                        
+                        writer.writerow(
+                            [
+                                result.allocation_id,
+                                result.public_ip,
+                                result.region,
+                                result.domain,
+                                result.is_attached,
+                                result.instance_id or "",
+                                f"${result.monthly_cost:.2f}",
+                                f"${result.annual_cost:.2f}",
+                                f"${result.potential_monthly_savings:.2f}",
+                                f"${result.potential_annual_savings:.2f}",
+                                result.optimization_recommendation,
+                                result.risk_level,
+                                len(result.dns_references),
+                            ]
+                        )
+
             elif export_format.lower() == "markdown":
-                with open(output_file, 'w') as f:
+                with open(output_file, "w") as f:
                     f.write(f"# Elastic IP Cost Optimization Report\n\n")
                     f.write(f"**Analysis Date**: {results.analysis_timestamp}\n")
                     f.write(f"**Total Elastic IPs**: {results.total_elastic_ips}\n")
@@ -611,16 +665,22 @@ class ElasticIPOptimizer:
                     f.write(f"**Total Annual Cost**: ${results.total_annual_cost:.2f}\n")
                     f.write(f"**Potential Annual Savings**: ${results.potential_annual_savings:.2f}\n\n")
                     f.write(f"## Optimization Recommendations\n\n")
-                    f.write(f"| Public IP | Region | Status | Annual Cost | Potential Savings | Recommendation | Risk |\n")
-                    f.write(f"|-----------|--------|--------|-------------|-------------------|----------------|------|\n")
+                    f.write(
+                        f"| Public IP | Region | Status | Annual Cost | Potential Savings | Recommendation | Risk |\n"
+                    )
+                    f.write(
+                        f"|-----------|--------|--------|-------------|-------------------|----------------|------|\n"
+                    )
                     for result in results.optimization_results:
                         status = "Attached" if result.is_attached else "Unattached"
                         f.write(f"| {result.public_ip} | {result.region} | {status} | ${result.annual_cost:.2f} | ")
-                        f.write(f"${result.potential_annual_savings:.2f} | {result.optimization_recommendation} | {result.risk_level} |\n")
-            
+                        f.write(
+                            f"${result.potential_annual_savings:.2f} | {result.optimization_recommendation} | {result.risk_level} |\n"
+                        )
+
             print_success(f"Results exported to: {output_file}")
             return output_file
-            
+
         except Exception as e:
             print_error(f"Export failed: {str(e)}")
             raise
@@ -628,20 +688,21 @@ class ElasticIPOptimizer:
 
 # CLI Integration for enterprise runbooks commands
 @click.command()
-@click.option('--profile', help='AWS profile name (3-tier priority: User > Environment > Default)')
-@click.option('--regions', multiple=True, help='AWS regions to analyze (space-separated)')
-@click.option('--dry-run/--no-dry-run', default=True, help='Execute in dry-run mode (READ-ONLY analysis)')
-@click.option('--export-format', type=click.Choice(['json', 'csv', 'markdown']), 
-              default='json', help='Export format for results')
-@click.option('--output-file', help='Output file path for results export')
+@click.option("--profile", help="AWS profile name (3-tier priority: User > Environment > Default)")
+@click.option("--regions", multiple=True, help="AWS regions to analyze (space-separated)")
+@click.option("--dry-run/--no-dry-run", default=True, help="Execute in dry-run mode (READ-ONLY analysis)")
+@click.option(
+    "--export-format", type=click.Choice(["json", "csv", "markdown"]), default="json", help="Export format for results"
+)
+@click.option("--output-file", help="Output file path for results export")
 def elastic_ip_optimizer(profile, regions, dry_run, export_format, output_file):
     """
     Elastic IP Cost Optimizer - Enterprise Multi-Region Analysis
-    
+
     Part of $132,720+ annual savings methodology targeting direct cost elimination.
-    
+
     SAFETY: READ-ONLY analysis only - no resource modifications.
-    
+
     Examples:
         runbooks finops elastic-ip --cleanup
         runbooks finops elastic-ip --profile my-profile --regions us-east-1 us-west-2
@@ -649,24 +710,23 @@ def elastic_ip_optimizer(profile, regions, dry_run, export_format, output_file):
     """
     try:
         # Initialize optimizer
-        optimizer = ElasticIPOptimizer(
-            profile_name=profile,
-            regions=list(regions) if regions else None
-        )
-        
+        optimizer = ElasticIPOptimizer(profile_name=profile, regions=list(regions) if regions else None)
+
         # Execute analysis
         results = asyncio.run(optimizer.analyze_elastic_ips(dry_run=dry_run))
-        
+
         # Export results if requested
-        if output_file or export_format != 'json':
+        if output_file or export_format != "json":
             optimizer.export_results(results, output_file, export_format)
-            
+
         # Display final success message
         if results.potential_annual_savings > 0:
-            print_success(f"Analysis complete: {format_cost(results.potential_annual_savings)} potential annual savings identified")
+            print_success(
+                f"Analysis complete: {format_cost(results.potential_annual_savings)} potential annual savings identified"
+            )
         else:
             print_info("Analysis complete: All Elastic IPs are optimally configured")
-            
+
     except KeyboardInterrupt:
         print_warning("Analysis interrupted by user")
         raise click.Abort()
@@ -675,5 +735,5 @@ def elastic_ip_optimizer(profile, regions, dry_run, export_format, output_file):
         raise click.Abort()
 
 
-if __name__ == '__main__':
-    elastic_ip_optimizer()
+if __name__ == "__main__":
+    elastic_ip_optimizer()