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

runbooks/cloudops/interfaces.py

@@ -45,8 +45,17 @@ from dataclasses import dataclass, asdict
 import warnings
 
 from runbooks.common.rich_utils import (
-    console, print_header, print_success, print_error, print_warning, print_info,
-    create_table, create_progress_bar, format_cost, create_panel, STATUS_INDICATORS
+    console,
+    print_header,
+    print_success,
+    print_error,
+    print_warning,
+    print_info,
+    create_table,
+    create_progress_bar,
+    format_cost,
+    create_panel,
+    STATUS_INDICATORS,
 )
 
 from .base import CloudOpsBase
@@ -56,17 +65,25 @@ from .lifecycle_manager import ResourceLifecycleManager
 from .infrastructure_optimizer import InfrastructureOptimizer
 from .monitoring_automation import MonitoringAutomation
 from .models import (
-    BusinessScenario, ExecutionMode, RiskLevel, 
-    CloudOpsExecutionResult, CostOptimizationResult, SecurityEnforcementResult,
-    BusinessMetrics, ResourceImpact, ComplianceMetrics
+    BusinessScenario,
+    ExecutionMode,
+    RiskLevel,
+    CloudOpsExecutionResult,
+    CostOptimizationResult,
+    SecurityEnforcementResult,
+    BusinessMetrics,
+    ResourceImpact,
+    ComplianceMetrics,
 )
 
 # Suppress warnings for cleaner notebook output
 warnings.filterwarnings("ignore", category=UserWarning)
 
+
 @dataclass
 class BusinessResultSummary:
     """Executive-ready result summary for business stakeholders."""
+
     scenario_name: str
     success: bool
     execution_time_seconds: float
@@ -78,7 +95,7 @@ class BusinessResultSummary:
     security_improvement: Optional[float] = None
     roi_percentage: Optional[str] = None
     risk_level: str = "medium"
-    
+
     @property
     def executive_summary(self) -> str:
         """Generate executive summary text."""
@@ -88,7 +105,7 @@ class BusinessResultSummary:
 💰 Financial Impact:
    • Monthly savings: ${self.monthly_savings:,.2f}
    • Annual impact: ${self.annual_impact:,.2f}
-   • ROI: {self.roi_percentage or 'Immediate'}
+   • ROI: {self.roi_percentage or "Immediate"}
 
 📊 Operational Results:
    • Resources analyzed: {self.resources_analyzed:,}
@@ -99,68 +116,70 @@ class BusinessResultSummary:
 {f"🔒 Compliance: {self.compliance_score:.1f}% score" if self.compliance_score else ""}
 {f"🛡️  Security: +{self.security_improvement:.1f}% improvement" if self.security_improvement else ""}
 
-Status: {'✅ SUCCESS' if self.success else '❌ NEEDS ATTENTION'}
+Status: {"✅ SUCCESS" if self.success else "❌ NEEDS ATTENTION"}
         """.strip()
-    
+
     def export_reports(self, output_dir: str = "./tmp/cloudops-reports") -> Dict[str, str]:
         """Export business reports to specified directory."""
         output_path = Path(output_dir)
         output_path.mkdir(parents=True, exist_ok=True)
-        
+
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         scenario_slug = self.scenario_name.lower().replace(" ", "_").replace("-", "_")
-        
+
         exported_files = {}
-        
+
         try:
             # Export JSON summary
             json_file = output_path / f"{scenario_slug}_summary_{timestamp}.json"
-            with open(json_file, 'w') as f:
+            with open(json_file, "w") as f:
                 json.dump(asdict(self), f, indent=2, default=str)
-            exported_files['json'] = str(json_file)
-            
+            exported_files["json"] = str(json_file)
+
             # Export executive markdown
             md_file = output_path / f"{scenario_slug}_executive_summary_{timestamp}.md"
-            with open(md_file, 'w') as f:
+            with open(md_file, "w") as f:
                 f.write(f"# {self.scenario_name}\n\n")
                 f.write(f"**Generated**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
                 f.write(self.executive_summary)
-            exported_files['markdown'] = str(md_file)
-            
+            exported_files["markdown"] = str(md_file)
+
             print_success(f"📊 Reports exported to: {output_dir}")
             print_info(f"   • JSON: {json_file.name}")
             print_info(f"   • Markdown: {md_file.name}")
-            
+
         except Exception as e:
             print_warning(f"Report export will be available after directory permissions are configured: {str(e)}")
-            exported_files['error'] = str(e)
-        
+            exported_files["error"] = str(e)
+
         return exported_files
 
+
 def _run_async_operation(coro_func, operation_name: str = "CloudOps Operation"):
     """
     Run async operation with proper event loop management.
-    
+
     Handles both existing and new event loops for notebook compatibility.
     """
     print_info(f"🚀 Executing {operation_name}...")
-    
+
     try:
         # Try to get existing event loop (common in notebooks)
         loop = asyncio.get_event_loop()
         if loop.is_running():
             # If loop is running (like in Jupyter), create new task
             import nest_asyncio
+
             nest_asyncio.apply()
             return loop.run_until_complete(coro_func)
         else:
             # If loop exists but not running, use it
             return loop.run_until_complete(coro_func)
-            
+
     except RuntimeError:
         # No event loop exists, create new one
         return asyncio.run(coro_func)
-    
+
     except ImportError:
         # nest_asyncio not available, try direct approach
         try:
@@ -170,20 +189,22 @@ def _run_async_operation(coro_func, operation_name: str = "CloudOps Operation"):
             print_warning("💡 For notebook usage, try: pip install nest-asyncio")
             raise
 
+
 def _validate_business_parameters(**kwargs) -> None:
     """Validate business parameters with helpful error messages."""
-    profile = kwargs.get('profile')
+    profile = kwargs.get("profile")
     if profile and not isinstance(profile, str):
         raise ValueError("Profile must be a string (e.g., 'billing', 'management', 'operations')")
-    
-    cost_threshold = kwargs.get('cost_spike_threshold') or kwargs.get('cost_threshold')
+
+    cost_threshold = kwargs.get("cost_spike_threshold") or kwargs.get("cost_threshold")
     if cost_threshold is not None and cost_threshold <= 0:
         raise ValueError("Cost threshold must be positive (e.g., 25000 for $25,000)")
-    
-    savings_percent = kwargs.get('target_savings_percent')
+
+    savings_percent = kwargs.get("target_savings_percent")
     if savings_percent is not None and not (0 < savings_percent <= 100):
         raise ValueError("Savings percentage must be between 1-100 (e.g., 30 for 30%)")
 
+
 def emergency_cost_response(
     profile: str = "default",
     cost_spike_threshold: float = 25000.0,
@@ -191,15 +212,15 @@ def emergency_cost_response(
     analysis_days: int = 7,
     max_risk_level: str = "medium",
     require_approval: bool = True,
-    dry_run: bool = True
+    dry_run: bool = True,
 ) -> BusinessResultSummary:
     """
     Execute emergency cost response for unexpected AWS cost spikes.
-    
+
     Business Scenario:
         Rapid response to cost spikes requiring immediate executive action.
         Typical triggers: Monthly bill increase >$5K, daily spending >200% budget.
-        
+
     Args:
         profile: AWS profile name (e.g., "billing", "management")
         cost_spike_threshold: Minimum cost increase ($) that triggered emergency
@@ -208,10 +229,10 @@ def emergency_cost_response(
         max_risk_level: Maximum acceptable risk ("low", "medium", "high")
         require_approval: Require executive approval for high-impact changes
         dry_run: Safe analysis mode (recommended for business users)
-    
+
     Returns:
         BusinessResultSummary with executive-ready results and export capabilities
-        
+
     Example:
         ```python
         result = emergency_cost_response(
@@ -224,49 +245,43 @@ def emergency_cost_response(
         ```
     """
     print_header("Emergency Cost Response - Business Analysis")
-    
+
     # Validate business parameters
     _validate_business_parameters(
-        profile=profile,
-        cost_spike_threshold=cost_spike_threshold,
-        target_savings_percent=target_savings_percent
+        profile=profile, cost_spike_threshold=cost_spike_threshold, target_savings_percent=target_savings_percent
     )
-    
+
     # Convert business risk to system enum
     risk_mapping = {"low": RiskLevel.LOW, "medium": RiskLevel.MEDIUM, "high": RiskLevel.HIGH}
     risk_level = risk_mapping.get(max_risk_level.lower(), RiskLevel.MEDIUM)
-    
+
     print_info(f"💰 Cost spike threshold: ${cost_spike_threshold:,.2f}")
     print_info(f"🎯 Target savings: {target_savings_percent}%")
     print_info(f"🛡️  Risk tolerance: {max_risk_level.title()}")
     print_info(f"⏱️  Analysis window: {analysis_days} days")
-    
+
     start_time = time.time()
-    
+
     try:
         # Initialize cost optimizer with business-safe settings
         cost_optimizer = CostOptimizer(
             profile=profile,
             dry_run=dry_run,
-            execution_mode=ExecutionMode.VALIDATE_ONLY if require_approval else ExecutionMode.DRY_RUN
+            execution_mode=ExecutionMode.VALIDATE_ONLY if require_approval else ExecutionMode.DRY_RUN,
         )
-        
+
         # Execute emergency cost analysis
         async def run_emergency_analysis():
             return await cost_optimizer.emergency_cost_response(
-                cost_spike_threshold=cost_spike_threshold,
-                analysis_days=analysis_days
+                cost_spike_threshold=cost_spike_threshold, analysis_days=analysis_days
             )
-        
-        result = _run_async_operation(
-            run_emergency_analysis(),
-            "Emergency Cost Spike Analysis"
-        )
-        
+
+        result = _run_async_operation(run_emergency_analysis(), "Emergency Cost Spike Analysis")
+
         # Transform to business-friendly summary
         execution_time = time.time() - start_time
         monthly_savings = result.business_metrics.total_monthly_savings
-        
+
         business_summary = BusinessResultSummary(
             scenario_name="Emergency Cost Response",
             success=result.success,
@@ -276,9 +291,9 @@ def emergency_cost_response(
             resources_analyzed=result.resources_analyzed,
             resources_impacted=len(result.resources_impacted),
             roi_percentage="Immediate",
-            risk_level=result.business_metrics.overall_risk_level.value
+            risk_level=result.business_metrics.overall_risk_level.value,
         )
-        
+
         # Display Rich CLI summary
         summary_panel = create_panel(
             f"""💰 Emergency Analysis Complete
@@ -291,21 +306,21 @@ Risk Level: {business_summary.risk_level.title()}
 
 ✅ Ready for Executive Review""",
             title="Emergency Cost Response Results",
-            border_style="green" if result.success else "red"
+            border_style="green" if result.success else "red",
         )
         console.print(summary_panel)
-        
+
         return business_summary
-        
+
     except Exception as e:
         print_error(f"Emergency cost analysis encountered an issue: {str(e)}")
         print_info("💡 This typically indicates AWS profile or permissions setup is needed")
         print_info("📞 Contact CloudOps team for AWS access configuration")
-        
+
         # Return demonstration result for business planning
         execution_time = time.time() - start_time
         demo_savings = cost_spike_threshold * (target_savings_percent / 100)
-        
+
         return BusinessResultSummary(
             scenario_name="Emergency Cost Response (Demo Mode)",
             success=False,
@@ -313,90 +328,87 @@ Risk Level: {business_summary.risk_level.title()}
             monthly_savings=demo_savings,
             annual_impact=demo_savings * 12,
             resources_analyzed=100,  # Estimated
-            resources_impacted=25,   # Estimated
+            resources_impacted=25,  # Estimated
             roi_percentage="Immediate",
-            risk_level=max_risk_level
+            risk_level=max_risk_level,
         )
 
+
 def optimize_unused_resources(
     profile: str = "default",
     resource_types: Optional[List[str]] = None,
     minimum_cost_threshold: float = 50.0,
     idle_days_threshold: int = 7,
-    dry_run: bool = True
+    dry_run: bool = True,
 ) -> BusinessResultSummary:
     """
     Identify and optimize unused AWS resources for immediate cost savings.
-    
+
     Business Scenario:
         Find unused resources (NAT Gateways, EBS volumes, idle EC2) for quick wins.
         Focus on resources with clear business impact and low operational risk.
-        
+
     Args:
         profile: AWS profile name for resource analysis
         resource_types: Resource types to analyze (None = all types)
         minimum_cost_threshold: Minimum monthly cost to consider ($)
         idle_days_threshold: Days of inactivity to consider resource unused
         dry_run: Safe analysis mode (recommended)
-        
+
     Returns:
         BusinessResultSummary with optimization opportunities
     """
     print_header("Unused Resource Optimization - Business Analysis")
-    
+
     _validate_business_parameters(profile=profile, cost_threshold=minimum_cost_threshold)
-    
+
     if resource_types is None:
         resource_types = ["nat-gateway", "ebs-volume", "ec2-instance", "elastic-ip"]
-    
+
     print_info(f"🔍 Analyzing resource types: {', '.join(resource_types)}")
     print_info(f"💰 Cost threshold: ${minimum_cost_threshold:,.2f}/month")
     print_info(f"⏱️  Idle threshold: {idle_days_threshold} days")
-    
+
     start_time = time.time()
-    
+
     try:
         cost_optimizer = CostOptimizer(profile=profile, dry_run=dry_run)
-        
+
         total_savings = 0.0
         total_resources = 0
         impacted_resources = 0
-        
+
         async def analyze_unused_resources():
             nonlocal total_savings, total_resources, impacted_resources
-            
+
             # Analyze NAT Gateways (typically significant value range/month each)
             if "nat-gateway" in resource_types:
                 print_info("🌐 Analyzing unused NAT Gateways...")
                 nat_result = await cost_optimizer.optimize_nat_gateways(
-                    idle_threshold_days=idle_days_threshold,
-                    cost_threshold=minimum_cost_threshold
+                    idle_threshold_days=idle_days_threshold, cost_threshold=minimum_cost_threshold
                 )
                 total_savings += nat_result.business_metrics.total_monthly_savings
                 total_resources += nat_result.resources_analyzed
                 impacted_resources += len(nat_result.resources_impacted)
-            
+
             # Analyze idle EC2 instances
             if "ec2-instance" in resource_types:
                 print_info("🖥️  Analyzing idle EC2 instances...")
                 ec2_result = await cost_optimizer.optimize_idle_ec2_instances(
-                    cpu_threshold=5.0,
-                    duration_hours=idle_days_threshold * 24,
-                    cost_threshold=minimum_cost_threshold
+                    cpu_threshold=5.0, duration_hours=idle_days_threshold * 24, cost_threshold=minimum_cost_threshold
                 )
                 total_savings += ec2_result.business_metrics.total_monthly_savings
                 total_resources += ec2_result.resources_analyzed
                 impacted_resources += len(ec2_result.resources_impacted)
-            
+
             return total_savings, total_resources, impacted_resources
-        
+
         total_savings, total_resources, impacted_resources = _run_async_operation(
-            analyze_unused_resources(),
-            "Unused Resource Analysis"
+            analyze_unused_resources(), "Unused Resource Analysis"
         )
-        
+
         execution_time = time.time() - start_time
-        
+
         business_summary = BusinessResultSummary(
             scenario_name="Unused Resource Optimization",
             success=True,
@@ -406,9 +418,9 @@ def optimize_unused_resources(
             resources_analyzed=total_resources,
             resources_impacted=impacted_resources,
             roi_percentage="Immediate",
-            risk_level="low"
+            risk_level="low",
         )
-        
+
         # Display optimization results
         optimization_panel = create_panel(
             f"""🔍 Resource Optimization Complete
@@ -421,12 +433,12 @@ Annual Impact: {format_cost(total_savings * 12)}
 
 💡 Optimization Focus: Low-risk unused resources""",
             title="Resource Optimization Results",
-            border_style="green"
+            border_style="green",
         )
         console.print(optimization_panel)
-        
+
         return business_summary
-        
+
     except Exception as e:
         print_error(f"Resource optimization analysis failed: {str(e)}")
         return BusinessResultSummary(
@@ -437,9 +449,10 @@ Annual Impact: {format_cost(total_savings * 12)}
             annual_impact=0.0,
             resources_analyzed=0,
             resources_impacted=0,
-            risk_level="unknown"
+            risk_level="unknown",
         )
 
+
 def governance_campaign(
     management_profile: str = "default",
     billing_profile: Optional[str] = None,
@@ -447,15 +460,15 @@ def governance_campaign(
     target_compliance_score: float = 95.0,
     max_concurrent_accounts: int = 15,
     governance_frameworks: Optional[List[str]] = None,
-    dry_run: bool = True
+    dry_run: bool = True,
 ) -> BusinessResultSummary:
     """
     Execute organization-wide governance campaign across multiple AWS accounts.
-    
+
     Business Scenario:
         Enforce governance policies across AWS Organizations for compliance,
         cost optimization, and operational efficiency improvements.
-        
+
     Args:
         management_profile: AWS Organizations management account profile
         billing_profile: Cost analysis profile (defaults to management_profile)
@@ -464,39 +477,33 @@ def governance_campaign(
         max_concurrent_accounts: Maximum accounts to process simultaneously
         governance_frameworks: Compliance frameworks to validate
         dry_run: Safe analysis mode
-        
+
     Returns:
         BusinessResultSummary with governance campaign results
     """
     print_header("Multi-Account Governance Campaign - Executive Analysis")
-    
+
     if billing_profile is None:
         billing_profile = management_profile
-        
+
     if governance_frameworks is None:
         governance_frameworks = ["AWS-Well-Architected", "SOC2", "PCI-DSS"]
-    
+
     _validate_business_parameters(profile=management_profile)
-    
+
     print_info(f"🏛️  Governance scope: {scope.title()}")
     print_info(f"📊 Target compliance: {target_compliance_score}%")
     print_info(f"⚡ Max concurrent accounts: {max_concurrent_accounts}")
     print_info(f"📋 Frameworks: {', '.join(governance_frameworks)}")
-    
+
     start_time = time.time()
-    
+
     try:
         # Initialize governance components
-        lifecycle_manager = ResourceLifecycleManager(
-            profile=management_profile,
-            dry_run=dry_run
-        )
-        
-        security_enforcer = SecurityEnforcer(
-            profile=management_profile,
-            dry_run=dry_run
-        )
-        
+        lifecycle_manager = ResourceLifecycleManager(profile=management_profile, dry_run=dry_run)
+
+        security_enforcer = SecurityEnforcer(profile=management_profile, dry_run=dry_run)
+
         async def run_governance_campaign():
             # Simulate governance campaign execution
             # In production, this would integrate with:
@@ -504,68 +511,67 @@ def governance_campaign(
             # - Tagging governance
             # - Security policy enforcement
             # - Cost governance
-            
+
             print_info("🔍 Discovering organization structure...")
             await asyncio.sleep(1)  # Simulate discovery
-            
+
             print_info("🏷️  Enforcing tagging governance...")
             await asyncio.sleep(2)  # Simulate tagging
-            
+
             print_info("🔒 Enforcing security policies...")
             security_result = await security_enforcer.enforce_s3_encryption()
-            
+
             print_info("💰 Analyzing cost governance...")
             await asyncio.sleep(1)  # Simulate cost analysis
-            
+
             # Aggregate results
             return {
-                'accounts_processed': min(max_concurrent_accounts, 10),
-                'compliance_improvement': 15.0,
-                'security_violations_fixed': security_result.violations_fixed if hasattr(security_result, 'violations_fixed') else 50,
-                'cost_governance_savings': 18750.0,  # Estimated
-                'resources_analyzed': 2500
+                "accounts_processed": min(max_concurrent_accounts, 10),
+                "compliance_improvement": 15.0,
+                "security_violations_fixed": security_result.violations_fixed
+                if hasattr(security_result, "violations_fixed")
+                else 50,
+                "cost_governance_savings": 18750.0,  # Estimated
+                "resources_analyzed": 2500,
             }
-        
-        campaign_results = _run_async_operation(
-            run_governance_campaign(),
-            "Multi-Account Governance Campaign"
-        )
-        
+
+        campaign_results = _run_async_operation(run_governance_campaign(), "Multi-Account Governance Campaign")
+
         execution_time = time.time() - start_time
-        monthly_savings = campaign_results['cost_governance_savings']
-        
+        monthly_savings = campaign_results["cost_governance_savings"]
+
         business_summary = BusinessResultSummary(
             scenario_name="Multi-Account Governance Campaign",
             success=True,
             execution_time_seconds=execution_time,
             monthly_savings=monthly_savings,
             annual_impact=monthly_savings * 12,
-            resources_analyzed=campaign_results['resources_analyzed'],
-            resources_impacted=campaign_results['security_violations_fixed'],
+            resources_analyzed=campaign_results["resources_analyzed"],
+            resources_impacted=campaign_results["security_violations_fixed"],
             compliance_score=target_compliance_score - 5.0,  # Current vs target gap
-            security_improvement=campaign_results['compliance_improvement'],
+            security_improvement=campaign_results["compliance_improvement"],
             roi_percentage="Immediate",
-            risk_level="medium"
+            risk_level="medium",
         )
-        
+
         # Display governance results
         governance_panel = create_panel(
             f"""🏛️  Governance Campaign Complete
             
-Accounts Processed: {campaign_results['accounts_processed']}
-Resources Analyzed: {campaign_results['resources_analyzed']:,}
-Security Improvement: +{campaign_results['compliance_improvement']:.1f}%
+Accounts Processed: {campaign_results["accounts_processed"]}
+Resources Analyzed: {campaign_results["resources_analyzed"]:,}
+Security Improvement: +{campaign_results["compliance_improvement"]:.1f}%
 Monthly Cost Savings: {format_cost(monthly_savings)}
-Violations Remediated: {campaign_results['security_violations_fixed']}
+Violations Remediated: {campaign_results["security_violations_fixed"]}
 
 ✅ Organization-wide governance enhanced""",
-            title="Governance Campaign Results", 
-            border_style="green"
+            title="Governance Campaign Results",
+            border_style="green",
         )
         console.print(governance_panel)
-        
+
         return business_summary
-        
+
     except Exception as e:
         print_error(f"Governance campaign encountered an issue: {str(e)}")
         return BusinessResultSummary(
@@ -578,23 +584,24 @@ Violations Remediated: {campaign_results['security_violations_fixed']}
             resources_impacted=200,
             compliance_score=85.0,
             security_improvement=10.0,
-            risk_level="medium"
+            risk_level="medium",
         )
 
+
 def security_incident_response(
     profile: str = "default",
     incident_type: str = "security_violation",
     compliance_frameworks: Optional[List[str]] = None,
     auto_remediate: bool = False,
-    notification_emails: Optional[List[str]] = None
+    notification_emails: Optional[List[str]] = None,
 ) -> BusinessResultSummary:
     """
     Respond to security incidents with automated analysis and remediation.
-    
+
     Business Scenario:
         Rapid security incident response with compliance validation and
         automated remediation for common security violations.
-        
+
     Args:
         profile: AWS profile for security operations
         incident_type: Type of security incident to address
@@ -603,22 +610,19 @@ def security_incident_response(
         notification_emails: Stakeholder emails for incident notifications
     """
     print_header("Security Incident Response - Business Analysis")
-    
+
     if compliance_frameworks is None:
         compliance_frameworks = ["SOC2", "PCI-DSS", "HIPAA"]
-        
+
     print_info(f"🚨 Incident type: {incident_type.replace('_', ' ').title()}")
     print_info(f"📋 Compliance frameworks: {', '.join(compliance_frameworks)}")
     print_info(f"🔧 Auto-remediation: {'Enabled' if auto_remediate else 'Disabled'}")
-    
+
     start_time = time.time()
-    
+
     try:
-        security_enforcer = SecurityEnforcer(
-            profile=profile,
-            dry_run=not auto_remediate
-        )
-        
+        security_enforcer = SecurityEnforcer(profile=profile, dry_run=not auto_remediate)
+
         async def run_incident_response():
             if incident_type == "s3_encryption":
                 return await security_enforcer.enforce_s3_encryption()
@@ -632,24 +636,21 @@ def security_incident_response(
                 print_info("🔍 Running comprehensive security assessment...")
                 await asyncio.sleep(3)
                 return None
-        
-        security_result = _run_async_operation(
-            run_incident_response(),
-            "Security Incident Response"
-        )
-        
+
+        security_result = _run_async_operation(run_incident_response(), "Security Incident Response")
+
         execution_time = time.time() - start_time
-        
+
         # Extract results or use defaults
         if security_result:
-            violations_found = getattr(security_result, 'violations_found', 25)
-            violations_fixed = getattr(security_result, 'violations_fixed', 20)
+            violations_found = getattr(security_result, "violations_found", 25)
+            violations_fixed = getattr(security_result, "violations_fixed", 20)
             security_improvement = 15.0
         else:
             violations_found = 25
             violations_fixed = 20
             security_improvement = 15.0
-        
+
         business_summary = BusinessResultSummary(
             scenario_name="Security Incident Response",
             success=True,
@@ -659,27 +660,27 @@ def security_incident_response(
             resources_analyzed=violations_found + 50,  # Total resources scanned
             resources_impacted=violations_fixed,
             security_improvement=security_improvement,
-            risk_level="high"  # Security incidents are high priority
+            risk_level="high",  # Security incidents are high priority
         )
-        
+
         # Display security response results
         security_panel = create_panel(
             f"""🚨 Security Response Complete
             
-Incident Type: {incident_type.replace('_', ' ').title()}
+Incident Type: {incident_type.replace("_", " ").title()}
 Security Violations Found: {violations_found}
 Violations Remediated: {violations_fixed}
 Security Improvement: +{security_improvement:.1f}%
-Auto-remediation: {'Enabled' if auto_remediate else 'Analysis Only'}
+Auto-remediation: {"Enabled" if auto_remediate else "Analysis Only"}
 
 🛡️  Security posture enhanced""",
             title="Security Incident Response Results",
-            border_style="red" if violations_found > violations_fixed else "green"
+            border_style="red" if violations_found > violations_fixed else "green",
         )
         console.print(security_panel)
-        
+
         return business_summary
-        
+
     except Exception as e:
         print_error(f"Security incident response failed: {str(e)}")
         return BusinessResultSummary(
@@ -690,23 +691,24 @@ Auto-remediation: {'Enabled' if auto_remediate else 'Analysis Only'}
             annual_impact=0.0,
             resources_analyzed=0,
             resources_impacted=0,
-            risk_level="critical"
+            risk_level="critical",
         )
 
+
 def optimize_infrastructure(
     profile: str = "default",
     optimization_targets: Optional[List[str]] = None,
     performance_requirements: Optional[Dict[str, float]] = None,
     cost_reduction_target: float = 25.0,
-    dry_run: bool = True
+    dry_run: bool = True,
 ) -> BusinessResultSummary:
     """
     Optimize infrastructure for cost, performance, and operational efficiency.
-    
+
     Business Scenario:
         Comprehensive infrastructure optimization covering rightsizing,
         reserved instances, storage optimization, and performance tuning.
-        
+
     Args:
         profile: AWS profile for infrastructure operations
         optimization_targets: Specific areas to optimize (compute, storage, network)
@@ -715,63 +717,59 @@ def optimize_infrastructure(
         dry_run: Safe analysis mode
     """
     print_header("Infrastructure Optimization - Business Analysis")
-    
+
     if optimization_targets is None:
         optimization_targets = ["compute", "storage", "network"]
-        
+
     if performance_requirements is None:
         performance_requirements = {
             "cpu_utilization_min": 20.0,
             "memory_utilization_min": 30.0,
-            "network_utilization_min": 10.0
+            "network_utilization_min": 10.0,
         }
-    
+
     print_info(f"🔧 Optimization targets: {', '.join(optimization_targets)}")
     print_info(f"🎯 Cost reduction target: {cost_reduction_target}%")
     print_info(f"⚡ Performance constraints maintained")
-    
+
     start_time = time.time()
-    
+
     try:
-        infra_optimizer = InfrastructureOptimizer(
-            profile=profile,
-            dry_run=dry_run
-        )
-        
+        infra_optimizer = InfrastructureOptimizer(profile=profile, dry_run=dry_run)
+
         async def run_infrastructure_optimization():
             print_info("🔍 Analyzing infrastructure utilization...")
             await asyncio.sleep(2)
-            
+
             print_info("💻 Optimizing compute resources...")
             await asyncio.sleep(2)
-            
+
             print_info("💾 Optimizing storage resources...")
             await asyncio.sleep(1)
-            
+
             print_info("🌐 Optimizing network resources...")
             await asyncio.sleep(1)
-            
+
             # Simulate optimization results
             return {
-                'compute_savings': 8500.0,
-                'storage_savings': 3200.0,
-                'network_savings': 1800.0,
-                'resources_optimized': 85,
-                'performance_maintained': True
+                "compute_savings": 8500.0,
+                "storage_savings": 3200.0,
+                "network_savings": 1800.0,
+                "resources_optimized": 85,
+                "performance_maintained": True,
             }
-        
-        optimization_results = _run_async_operation(
-            run_infrastructure_optimization(),
-            "Infrastructure Optimization"
-        )
-        
+
+        optimization_results = _run_async_operation(run_infrastructure_optimization(), "Infrastructure Optimization")
+
         execution_time = time.time() - start_time
-        total_savings = sum([
-            optimization_results['compute_savings'],
-            optimization_results['storage_savings'],
-            optimization_results['network_savings']
-        ])
-        
+        total_savings = sum(
+            [
+                optimization_results["compute_savings"],
+                optimization_results["storage_savings"],
+                optimization_results["network_savings"],
+            ]
+        )
+
         business_summary = BusinessResultSummary(
             scenario_name="Infrastructure Optimization",
             success=True,
@@ -779,31 +777,31 @@ def optimize_infrastructure(
             monthly_savings=total_savings,
             annual_impact=total_savings * 12,
             resources_analyzed=200,  # Estimated
-            resources_impacted=optimization_results['resources_optimized'],
+            resources_impacted=optimization_results["resources_optimized"],
             roi_percentage="3-6 months",
-            risk_level="low"
+            risk_level="low",
         )
-        
+
         # Display optimization results
         optimization_panel = create_panel(
             f"""🔧 Infrastructure Optimization Complete
             
-Compute Savings: {format_cost(optimization_results['compute_savings'])}/month
-Storage Savings: {format_cost(optimization_results['storage_savings'])}/month
-Network Savings: {format_cost(optimization_results['network_savings'])}/month
+Compute Savings: {format_cost(optimization_results["compute_savings"])}/month
+Storage Savings: {format_cost(optimization_results["storage_savings"])}/month
+Network Savings: {format_cost(optimization_results["network_savings"])}/month
 
 Total Monthly Savings: {format_cost(total_savings)}
-Resources Optimized: {optimization_results['resources_optimized']}
-Performance Impact: {'✅ Maintained' if optimization_results['performance_maintained'] else '⚠️ Review Required'}
+Resources Optimized: {optimization_results["resources_optimized"]}
+Performance Impact: {"✅ Maintained" if optimization_results["performance_maintained"] else "⚠️ Review Required"}
 
 💡 Optimization maintains all performance requirements""",
             title="Infrastructure Optimization Results",
-            border_style="green"
+            border_style="green",
         )
         console.print(optimization_panel)
-        
+
         return business_summary
-        
+
     except Exception as e:
         print_error(f"Infrastructure optimization failed: {str(e)}")
         return BusinessResultSummary(
@@ -814,15 +812,16 @@ Performance Impact: {'✅ Maintained' if optimization_results['performance_maint
             annual_impact=0.0,
             resources_analyzed=0,
             resources_impacted=0,
-            risk_level="medium"
+            risk_level="medium",
         )
 
+
 # Export all interface functions
 __all__ = [
     "BusinessResultSummary",
     "emergency_cost_response",
-    "optimize_unused_resources", 
+    "optimize_unused_resources",
     "governance_campaign",
     "security_incident_response",
-    "optimize_infrastructure"
-]
+    "optimize_infrastructure",
+]