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

runbooks/finops/notebook_utils.py

@@ -22,63 +22,85 @@ Strategic Alignment:
 - Universal $132K Cost Optimization Methodology: Executive ROI quantification
 """
 
+import json
 import os
 import sys
-import json
 import tempfile
-from datetime import datetime, timedelta
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Union, Tuple
 from dataclasses import dataclass, field
+from datetime import datetime, timedelta
 from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 # Jupyter and presentation imports
 try:
-    from IPython.display import display, HTML, Markdown, Image
     from IPython.core.display import Javascript
+    from IPython.display import HTML, Image, Markdown, display
+
     JUPYTER_AVAILABLE = True
 except ImportError:
     JUPYTER_AVAILABLE = False
+
     # Create stub classes for non-Jupyter environments
     class HTML:
-        def __init__(self, data): self.data = data
+        def __init__(self, data):
+            self.data = data
+
     class Markdown:
-        def __init__(self, data): self.data = data
+        def __init__(self, data):
+            self.data = data
+
     class Image:
-        def __init__(self, data): self.data = data
-    def display(*args): pass
+        def __init__(self, data):
+            self.data = data
+
+    def display(*args):
+        pass
+
 
 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 .automation_core import UniversalAutomationEngine, OptimizationCategory, BusinessImpactLevel
+from .automation_core import BusinessImpactLevel, OptimizationCategory, UniversalAutomationEngine
 
 
 class StakeholderType(str, Enum):
     """Target stakeholder types for business interfaces."""
-    CTO = "cto"                    # Chief Technology Officer
-    CFO = "cfo"                    # Chief Financial Officer  
-    PROCUREMENT = "procurement"    # Procurement teams
-    FINOPS = "finops"             # Financial Operations teams
-    MANAGER = "manager"           # General management
+
+    CTO = "cto"  # Chief Technology Officer
+    CFO = "cfo"  # Chief Financial Officer
+    PROCUREMENT = "procurement"  # Procurement teams
+    FINOPS = "finops"  # Financial Operations teams
+    MANAGER = "manager"  # General management
 
 
 class PresentationFormat(str, Enum):
     """Presentation output formats for stakeholders."""
-    JUPYTER = "jupyter"           # Interactive Jupyter notebook
-    HTML = "html"                 # Static HTML export
-    PDF = "pdf"                   # Executive PDF report
-    MARKDOWN = "markdown"         # Markdown documentation
-    JSON = "json"                 # Raw data export
+
+    JUPYTER = "jupyter"  # Interactive Jupyter notebook
+    HTML = "html"  # Static HTML export
+    PDF = "pdf"  # Executive PDF report
+    MARKDOWN = "markdown"  # Markdown documentation
+    JSON = "json"  # Raw data export
 
 
 @dataclass
 class BusinessConfiguration:
     """Business configuration for non-technical users."""
+
     analysis_scope: str = "multi_account"  # single_account, multi_account
     target_aws_profile: str = "default"
-    optimization_target: float = 0.25      # 25% cost reduction target
+    optimization_target: float = 0.25  # 25% cost reduction target
     executive_reporting: bool = True
     export_formats: List[str] = field(default_factory=lambda: ["json", "csv", "html"])
     stakeholder_type: StakeholderType = StakeholderType.MANAGER
@@ -87,6 +109,7 @@ class BusinessConfiguration:
 @dataclass
 class ExecutiveDashboardResult:
     """Executive dashboard analysis results."""
+
     business_summary: Dict[str, Any]
     financial_impact: Dict[str, Any]
     optimization_recommendations: List[Dict[str, Any]]
@@ -99,7 +122,7 @@ class ExecutiveDashboardResult:
 class ExecutiveDashboardCreator:
     """
     Executive Dashboard Creator - Business Interface for Non-Technical Stakeholders
-    
+
     Following Universal $132K Cost Optimization Methodology with executive focus:
     - CTO/CFO/Procurement ready cost analysis dashboards
     - Non-technical user interfaces with business configuration
@@ -108,62 +131,61 @@ class ExecutiveDashboardCreator:
     - MCP validation integration for executive-grade accuracy
     - Strategic business intelligence with implementation roadmaps
     """
-    
+
     def __init__(self, automation_engine: UniversalAutomationEngine = None):
         """Initialize executive dashboard creator with automation engine."""
         self.automation_engine = automation_engine or UniversalAutomationEngine()
         self.temp_dir = Path(tempfile.gettempdir()) / "finops_dashboards"
         self.temp_dir.mkdir(exist_ok=True)
-    
-    async def create_executive_dashboard(self, 
-                                       config: BusinessConfiguration,
-                                       optimization_focus: OptimizationCategory = None) -> ExecutiveDashboardResult:
+
+    async def create_executive_dashboard(
+        self, config: BusinessConfiguration, optimization_focus: OptimizationCategory = None
+    ) -> ExecutiveDashboardResult:
         """
         Create comprehensive executive dashboard for business stakeholders.
-        
+
         Args:
             config: Business configuration with stakeholder requirements
             optimization_focus: Specific optimization category focus
-            
+
         Returns:
             Complete executive dashboard with business intelligence
         """
         print_header("Executive Dashboard Creator", "Enterprise Business Intelligence Platform v1.0")
-        
+
         try:
             # Step 1: Business-focused resource analysis
             console.print("🔍 [bold blue]Executing Business-Focused Analysis...[/bold blue]")
             analysis_results = await self.automation_engine.discover_resources_universal(
                 optimization_focus=optimization_focus
             )
-            
+
             # Step 2: Executive business summary generation
             console.print("📊 [bold blue]Generating Executive Business Summary...[/bold blue]")
             business_summary = self._generate_business_summary(analysis_results, config)
-            
+
             # Step 3: Financial impact analysis for C-suite
             console.print("💰 [bold blue]Calculating Financial Impact Analysis...[/bold blue]")
             financial_impact = self._calculate_executive_financial_impact(analysis_results, config)
-            
+
             # Step 4: Strategic optimization recommendations
             console.print("🎯 [bold blue]Creating Strategic Recommendations...[/bold blue]")
             recommendations = self._generate_optimization_recommendations(analysis_results, config)
-            
+
             # Step 5: Implementation roadmap for executives
             console.print("🗺️ [bold blue]Building Implementation Roadmap...[/bold blue]")
             roadmap = self._create_implementation_roadmap(analysis_results, config)
-            
+
             # Step 6: Risk assessment for executive decision making
             console.print("⚠️ [bold blue]Generating Risk Assessment...[/bold blue]")
             risk_assessment = self._generate_risk_assessment(analysis_results, config)
-            
+
             # Step 7: Export generation for stakeholder distribution
             console.print("📤 [bold blue]Generating Executive Export Files...[/bold blue]")
             export_files = await self._generate_export_files(
-                analysis_results, business_summary, financial_impact, 
-                recommendations, roadmap, risk_assessment, config
+                analysis_results, business_summary, financial_impact, recommendations, roadmap, risk_assessment, config
             )
-            
+
             dashboard_result = ExecutiveDashboardResult(
                 business_summary=business_summary,
                 financial_impact=financial_impact,
@@ -171,23 +193,24 @@ class ExecutiveDashboardCreator:
                 implementation_roadmap=roadmap,
                 risk_assessment=risk_assessment,
                 export_files=export_files,
-                presentation_ready=True
+                presentation_ready=True,
             )
-            
+
             # Display executive summary
             self._display_executive_dashboard(dashboard_result, config)
-            
+
             return dashboard_result
-            
+
         except Exception as e:
             print_error(f"Executive dashboard creation failed: {e}")
             raise
-    
-    def _generate_business_summary(self, analysis_results: Dict[str, Any], 
-                                 config: BusinessConfiguration) -> Dict[str, Any]:
+
+    def _generate_business_summary(
+        self, analysis_results: Dict[str, Any], config: BusinessConfiguration
+    ) -> Dict[str, Any]:
         """Generate executive business summary."""
         business_impact = analysis_results["business_impact"]
-        
+
         return {
             "total_infrastructure_analyzed": analysis_results["total_resources_discovered"],
             "optimization_opportunities_identified": business_impact["total_opportunities"],
@@ -198,23 +221,26 @@ class ExecutiveDashboardCreator:
             "regions_covered": len(analysis_results["regions_covered"]),
             "analysis_timestamp": analysis_results["analysis_timestamp"],
             "strategic_alignment": {
-                "cost_optimization_target": f"{config.optimization_target*100}%",
+                "cost_optimization_target": f"{config.optimization_target * 100}%",
                 "stakeholder_focus": config.stakeholder_type.value.upper(),
-                "enterprise_readiness": "C-suite presentation ready"
-            }
+                "enterprise_readiness": "C-suite presentation ready",
+            },
         }
-    
-    def _calculate_executive_financial_impact(self, analysis_results: Dict[str, Any],
-                                            config: BusinessConfiguration) -> Dict[str, Any]:
+
+    def _calculate_executive_financial_impact(
+        self, analysis_results: Dict[str, Any], config: BusinessConfiguration
+    ) -> Dict[str, Any]:
         """Calculate financial impact for executive stakeholders."""
         business_impact = analysis_results["business_impact"]
         total_savings = business_impact["total_potential_annual_savings"]
-        
+
         # Calculate ROI metrics for executives
         implementation_cost = 50_000  # Conservative implementation cost estimate
         annual_savings = total_savings
-        roi_percentage = ((annual_savings - implementation_cost) / implementation_cost) * 100 if implementation_cost > 0 else 0
-        
+        roi_percentage = (
+            ((annual_savings - implementation_cost) / implementation_cost) * 100 if implementation_cost > 0 else 0
+        )
+
         return {
             "annual_cost_reduction": annual_savings,
             "monthly_savings": annual_savings / 12,
@@ -225,15 +251,16 @@ class ExecutiveDashboardCreator:
             "payback_period_months": (implementation_cost / (annual_savings / 12)) if annual_savings > 0 else 0,
             "three_year_value": (annual_savings * 3) - implementation_cost,
             "optimization_categories": business_impact["impact_by_category"],
-            "confidence_level": "High - Based on proven $132K methodology"
+            "confidence_level": "High - Based on proven $132K methodology",
         }
-    
-    def _generate_optimization_recommendations(self, analysis_results: Dict[str, Any],
-                                             config: BusinessConfiguration) -> List[Dict[str, Any]]:
+
+    def _generate_optimization_recommendations(
+        self, analysis_results: Dict[str, Any], config: BusinessConfiguration
+    ) -> List[Dict[str, Any]]:
         """Generate strategic optimization recommendations for executives."""
         recommendations = []
         business_impact = analysis_results["business_impact"]
-        
+
         # Priority recommendations based on business impact
         for category, impact_data in business_impact["impact_by_category"].items():
             recommendation = {
@@ -244,31 +271,32 @@ class ExecutiveDashboardCreator:
                 "resource_requirements": "Minimal - Automated analysis with human approval",
                 "risk_level": "Low - READ-ONLY analysis with safety controls",
                 "stakeholder_approval": "Required - Executive approval for implementation",
-                "success_criteria": f"≥{config.optimization_target*100}% cost reduction achieved"
+                "success_criteria": f"≥{config.optimization_target * 100}% cost reduction achieved",
             }
-            
+
             # Add category-specific recommendations
             if category == "cost_optimization":
                 recommendation["strategic_value"] = "Immediate financial impact with enterprise ROI"
                 recommendation["next_steps"] = [
                     "Executive approval for optimization implementation",
                     "Phased rollout with safety controls and monitoring",
-                    "Monthly savings validation and reporting"
+                    "Monthly savings validation and reporting",
                 ]
             elif category == "security_compliance":
                 recommendation["strategic_value"] = "Risk mitigation and regulatory compliance"
                 recommendation["next_steps"] = [
                     "Security team review and validation",
                     "Compliance framework alignment verification",
-                    "Automated remediation with audit trails"
+                    "Automated remediation with audit trails",
                 ]
-            
+
             recommendations.append(recommendation)
-        
+
         return recommendations
-    
-    def _create_implementation_roadmap(self, analysis_results: Dict[str, Any],
-                                     config: BusinessConfiguration) -> Dict[str, Any]:
+
+    def _create_implementation_roadmap(
+        self, analysis_results: Dict[str, Any], config: BusinessConfiguration
+    ) -> Dict[str, Any]:
         """Create strategic implementation roadmap for executives."""
         return {
             "phase_1_analysis": {
@@ -277,19 +305,19 @@ class ExecutiveDashboardCreator:
                 "deliverables": [
                     "Executive business case with quantified ROI",
                     "Risk assessment and mitigation strategy",
-                    "Implementation timeline and resource requirements"
+                    "Implementation timeline and resource requirements",
                 ],
-                "approval_required": "C-suite sign-off on optimization strategy"
+                "approval_required": "C-suite sign-off on optimization strategy",
             },
             "phase_2_implementation": {
-                "duration": "4-8 weeks", 
+                "duration": "4-8 weeks",
                 "objective": "Systematic optimization execution with safety controls",
                 "deliverables": [
                     "Automated optimization with human approval gates",
                     "Real-time monitoring and progress reporting",
-                    "Monthly savings validation and evidence collection"
+                    "Monthly savings validation and evidence collection",
                 ],
-                "approval_required": "Technical team validation and stakeholder updates"
+                "approval_required": "Technical team validation and stakeholder updates",
             },
             "phase_3_optimization": {
                 "duration": "Ongoing",
@@ -297,68 +325,72 @@ class ExecutiveDashboardCreator:
                 "deliverables": [
                     "Quarterly optimization reviews and adjustments",
                     "Annual ROI validation and strategic planning",
-                    "Enterprise scaling and additional optimization opportunities"
+                    "Enterprise scaling and additional optimization opportunities",
                 ],
-                "approval_required": "Quarterly executive review and strategic adjustment"
+                "approval_required": "Quarterly executive review and strategic adjustment",
             },
             "success_metrics": {
-                "financial": f"≥{config.optimization_target*100}% cost reduction achieved",
+                "financial": f"≥{config.optimization_target * 100}% cost reduction achieved",
                 "operational": "≥99.5% accuracy in cost projections and analysis",
-                "strategic": "Executive stakeholder satisfaction and continued investment"
-            }
+                "strategic": "Executive stakeholder satisfaction and continued investment",
+            },
         }
-    
-    def _generate_risk_assessment(self, analysis_results: Dict[str, Any],
-                                config: BusinessConfiguration) -> Dict[str, Any]:
+
+    def _generate_risk_assessment(
+        self, analysis_results: Dict[str, Any], config: BusinessConfiguration
+    ) -> Dict[str, Any]:
         """Generate comprehensive risk assessment for executive decision making."""
         return {
             "implementation_risks": {
                 "technical_risk": {
                     "level": "Low",
                     "description": "READ-ONLY analysis with established safety controls",
-                    "mitigation": "Proven automation patterns with ≥99.5% accuracy validation"
+                    "mitigation": "Proven automation patterns with ≥99.5% accuracy validation",
                 },
                 "financial_risk": {
-                    "level": "Low", 
+                    "level": "Low",
                     "description": "Conservative savings projections based on proven methodology",
-                    "mitigation": "Phased implementation with continuous ROI validation"
+                    "mitigation": "Phased implementation with continuous ROI validation",
                 },
                 "operational_risk": {
                     "level": "Medium",
                     "description": "Change management and stakeholder adoption requirements",
-                    "mitigation": "Executive sponsorship and comprehensive training program"
-                }
+                    "mitigation": "Executive sponsorship and comprehensive training program",
+                },
             },
             "business_continuity": {
                 "service_impact": "Minimal - Analysis and optimization during maintenance windows",
                 "rollback_capability": "Complete - All changes reversible with audit trails",
-                "monitoring_coverage": "Comprehensive - Real-time performance and cost monitoring"
+                "monitoring_coverage": "Comprehensive - Real-time performance and cost monitoring",
             },
             "regulatory_compliance": {
                 "frameworks_supported": ["SOC2", "PCI-DSS", "HIPAA", "AWS Well-Architected"],
                 "audit_readiness": "Complete audit trails with evidence collection",
-                "compliance_validation": "≥99.5% accuracy with MCP cross-validation"
+                "compliance_validation": "≥99.5% accuracy with MCP cross-validation",
             },
             "strategic_risks": {
                 "competitive_advantage": "High - Cost optimization enables strategic reinvestment",
                 "vendor_dependencies": "Low - Multi-cloud patterns with AWS expertise",
-                "skill_requirements": "Minimal - Automated systems with executive dashboards"
+                "skill_requirements": "Minimal - Automated systems with executive dashboards",
             },
             "overall_risk_rating": "Low Risk, High Reward",
-            "executive_recommendation": "Proceed with implementation following proven methodology"
+            "executive_recommendation": "Proceed with implementation following proven methodology",
         }
-    
-    async def _generate_export_files(self, analysis_results: Dict[str, Any],
-                                   business_summary: Dict[str, Any],
-                                   financial_impact: Dict[str, Any],
-                                   recommendations: List[Dict[str, Any]],
-                                   roadmap: Dict[str, Any],
-                                   risk_assessment: Dict[str, Any],
-                                   config: BusinessConfiguration) -> List[str]:
+
+    async def _generate_export_files(
+        self,
+        analysis_results: Dict[str, Any],
+        business_summary: Dict[str, Any],
+        financial_impact: Dict[str, Any],
+        recommendations: List[Dict[str, Any]],
+        roadmap: Dict[str, Any],
+        risk_assessment: Dict[str, Any],
+        config: BusinessConfiguration,
+    ) -> List[str]:
         """Generate export files for stakeholder distribution."""
         export_files = []
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        
+
         try:
             # Generate JSON export (detailed data)
             if "json" in config.export_formats:
@@ -370,41 +402,44 @@ class ExecutiveDashboardCreator:
                     "recommendations": recommendations,
                     "implementation_roadmap": roadmap,
                     "risk_assessment": risk_assessment,
-                    "generated_timestamp": datetime.now().isoformat()
+                    "generated_timestamp": datetime.now().isoformat(),
                 }
-                
-                with open(json_file, 'w') as f:
+
+                with open(json_file, "w") as f:
                     json.dump(export_data, f, indent=2, default=str)
                 export_files.append(str(json_file))
-            
+
             # Generate HTML export (executive presentation)
             if "html" in config.export_formats:
                 html_file = self.temp_dir / f"executive_dashboard_{timestamp}.html"
                 html_content = self._generate_html_report(
                     business_summary, financial_impact, recommendations, roadmap, risk_assessment, config
                 )
-                
-                with open(html_file, 'w') as f:
+
+                with open(html_file, "w") as f:
                     f.write(html_content)
                 export_files.append(str(html_file))
-            
+
             # Generate CSV export (financial data)
             if "csv" in config.export_formats:
                 csv_file = self.temp_dir / f"executive_financial_analysis_{timestamp}.csv"
                 self._generate_csv_export(financial_impact, recommendations, csv_file)
                 export_files.append(str(csv_file))
-            
+
         except Exception as e:
             print_warning(f"Export file generation incomplete: {str(e)}")
-        
+
         return export_files
-    
-    def _generate_html_report(self, business_summary: Dict[str, Any],
-                            financial_impact: Dict[str, Any],
-                            recommendations: List[Dict[str, Any]],
-                            roadmap: Dict[str, Any],
-                            risk_assessment: Dict[str, Any],
-                            config: BusinessConfiguration) -> str:
+
+    def _generate_html_report(
+        self,
+        business_summary: Dict[str, Any],
+        financial_impact: Dict[str, Any],
+        recommendations: List[Dict[str, Any]],
+        roadmap: Dict[str, Any],
+        risk_assessment: Dict[str, Any],
+        config: BusinessConfiguration,
+    ) -> str:
         """Generate HTML report for executive presentation."""
         html_template = f"""
         <!DOCTYPE html>
@@ -435,15 +470,15 @@ class ExecutiveDashboardCreator:
             <div class="summary">
                 <h2>Executive Business Summary</h2>
                 <div class="metric">
-                    <div class="metric-value">{business_summary['optimization_opportunities_identified']:,}</div>
+                    <div class="metric-value">{business_summary["optimization_opportunities_identified"]:,}</div>
                     <div class="metric-label">Optimization Opportunities</div>
                 </div>
                 <div class="metric">
-                    <div class="metric-value">{format_cost(business_summary['annual_savings_potential'])}</div>
+                    <div class="metric-value">{format_cost(business_summary["annual_savings_potential"])}</div>
                     <div class="metric-label">Annual Savings Potential</div>
                 </div>
                 <div class="metric">
-                    <div class="metric-value">{business_summary['roi_timeline_months']}</div>
+                    <div class="metric-value">{business_summary["roi_timeline_months"]}</div>
                     <div class="metric-label">ROI Timeline (Months)</div>
                 </div>
             </div>
@@ -452,10 +487,10 @@ class ExecutiveDashboardCreator:
                 <h2>Financial Impact Analysis</h2>
                 <table>
                     <tr><th>Metric</th><th>Value</th><th>Timeline</th></tr>
-                    <tr><td>Annual Cost Reduction</td><td>{format_cost(financial_impact['annual_cost_reduction'])}</td><td>12 months</td></tr>
-                    <tr><td>Monthly Savings</td><td>{format_cost(financial_impact['monthly_savings'])}</td><td>Ongoing</td></tr>
-                    <tr><td>ROI Percentage</td><td>{financial_impact['roi_percentage']:.1f}%</td><td>Annual</td></tr>
-                    <tr><td>Payback Period</td><td>{financial_impact['payback_period_months']:.1f} months</td><td>One-time</td></tr>
+                    <tr><td>Annual Cost Reduction</td><td>{format_cost(financial_impact["annual_cost_reduction"])}</td><td>12 months</td></tr>
+                    <tr><td>Monthly Savings</td><td>{format_cost(financial_impact["monthly_savings"])}</td><td>Ongoing</td></tr>
+                    <tr><td>ROI Percentage</td><td>{financial_impact["roi_percentage"]:.1f}%</td><td>Annual</td></tr>
+                    <tr><td>Payback Period</td><td>{financial_impact["payback_period_months"]:.1f} months</td><td>One-time</td></tr>
                 </table>
             </div>
             
@@ -464,77 +499,77 @@ class ExecutiveDashboardCreator:
                 <table>
                     <tr><th>Category</th><th>Priority</th><th>Business Impact</th><th>Timeline</th></tr>
         """
-        
+
         for rec in recommendations:
             html_template += f"""
                     <tr>
-                        <td>{rec['category']}</td>
-                        <td>{rec['priority']}</td>
-                        <td>{rec['business_impact']}</td>
-                        <td>{rec['implementation_timeline']}</td>
+                        <td>{rec["category"]}</td>
+                        <td>{rec["priority"]}</td>
+                        <td>{rec["business_impact"]}</td>
+                        <td>{rec["implementation_timeline"]}</td>
                     </tr>
             """
-        
+
         html_template += """
                 </table>
             </div>
         </body>
         </html>
         """
-        
+
         return html_template
-    
-    def _generate_csv_export(self, financial_impact: Dict[str, Any],
-                           recommendations: List[Dict[str, Any]],
-                           csv_file: Path) -> None:
+
+    def _generate_csv_export(
+        self, financial_impact: Dict[str, Any], recommendations: List[Dict[str, Any]], csv_file: Path
+    ) -> None:
         """Generate CSV export for financial data."""
         import csv
-        
-        with open(csv_file, 'w', newline='') as f:
+
+        with open(csv_file, "w", newline="") as f:
             writer = csv.writer(f)
-            
+
             # Financial metrics section
-            writer.writerow(['Financial Analysis'])
-            writer.writerow(['Metric', 'Value', 'Notes'])
-            writer.writerow(['Annual Cost Reduction', f"${financial_impact['annual_cost_reduction']:,.2f}", 'Conservative estimate'])
-            writer.writerow(['Monthly Savings', f"${financial_impact['monthly_savings']:,.2f}", 'Ongoing benefit'])
-            writer.writerow(['ROI Percentage', f"{financial_impact['roi_percentage']:.1f}%", 'Annual return'])
-            writer.writerow(['Payback Period', f"{financial_impact['payback_period_months']:.1f} months", 'Investment recovery'])
+            writer.writerow(["Financial Analysis"])
+            writer.writerow(["Metric", "Value", "Notes"])
+            writer.writerow(
+                ["Annual Cost Reduction", f"${financial_impact['annual_cost_reduction']:,.2f}", "Conservative estimate"]
+            )
+            writer.writerow(["Monthly Savings", f"${financial_impact['monthly_savings']:,.2f}", "Ongoing benefit"])
+            writer.writerow(["ROI Percentage", f"{financial_impact['roi_percentage']:.1f}%", "Annual return"])
+            writer.writerow(
+                ["Payback Period", f"{financial_impact['payback_period_months']:.1f} months", "Investment recovery"]
+            )
             writer.writerow([])  # Empty row
-            
+
             # Recommendations section
-            writer.writerow(['Strategic Recommendations'])
-            writer.writerow(['Category', 'Priority', 'Business Impact', 'Implementation Timeline'])
+            writer.writerow(["Strategic Recommendations"])
+            writer.writerow(["Category", "Priority", "Business Impact", "Implementation Timeline"])
             for rec in recommendations:
-                writer.writerow([
-                    rec['category'],
-                    rec['priority'], 
-                    rec['business_impact'],
-                    rec['implementation_timeline']
-                ])
-    
-    def _display_executive_dashboard(self, result: ExecutiveDashboardResult,
-                                   config: BusinessConfiguration) -> None:
+                writer.writerow(
+                    [rec["category"], rec["priority"], rec["business_impact"], rec["implementation_timeline"]]
+                )
+
+    def _display_executive_dashboard(self, result: ExecutiveDashboardResult, config: BusinessConfiguration) -> None:
         """Display executive dashboard summary."""
-        
+
         # Executive Summary Panel
         summary = result.business_summary
         financial = result.financial_impact
-        
+
         summary_content = f"""
 🏆 Executive Cost Optimization Dashboard
 
 📊 Business Intelligence Summary:
-   • Infrastructure Analyzed: {summary['total_infrastructure_analyzed']:,} resources
-   • Optimization Opportunities: {summary['optimization_opportunities_identified']:,}
-   • High-Impact Opportunities: {summary['high_impact_opportunities']:,}
-   • Annual Savings Potential: {format_cost(summary['annual_savings_potential'])}
+   • Infrastructure Analyzed: {summary["total_infrastructure_analyzed"]:,} resources
+   • Optimization Opportunities: {summary["optimization_opportunities_identified"]:,}
+   • High-Impact Opportunities: {summary["high_impact_opportunities"]:,}
+   • Annual Savings Potential: {format_cost(summary["annual_savings_potential"])}
 
 💰 Financial Impact Analysis:
-   • ROI Percentage: {financial['roi_percentage']:.1f}%
-   • Payback Period: {financial['payback_period_months']:.1f} months
-   • Net Annual Benefit: {format_cost(financial['net_annual_benefit'])}
-   • Three-Year Value: {format_cost(financial['three_year_value'])}
+   • ROI Percentage: {financial["roi_percentage"]:.1f}%
+   • Payback Period: {financial["payback_period_months"]:.1f} months
+   • Net Annual Benefit: {format_cost(financial["net_annual_benefit"])}
+   • Three-Year Value: {format_cost(financial["three_year_value"])}
 
 🎯 Executive Deliverables:
    • Strategic Recommendations: {len(result.optimization_recommendations)} categories
@@ -544,16 +579,18 @@ class ExecutiveDashboardCreator:
 
 📈 Strategic Alignment:
    • Stakeholder Focus: {config.stakeholder_type.value.upper()}
-   • Optimization Target: {config.optimization_target*100}%
-   • Presentation Ready: {'✅ Yes' if result.presentation_ready else '❌ No'}
+   • Optimization Target: {config.optimization_target * 100}%
+   • Presentation Ready: {"✅ Yes" if result.presentation_ready else "❌ No"}
         """
-        
-        console.print(create_panel(
-            summary_content.strip(),
-            title=f"🏆 Executive Dashboard - {config.stakeholder_type.value.upper()} Ready",
-            border_style="green"
-        ))
-        
+
+        console.print(
+            create_panel(
+                summary_content.strip(),
+                title=f"🏆 Executive Dashboard - {config.stakeholder_type.value.upper()} Ready",
+                border_style="green",
+            )
+        )
+
         if result.export_files:
             console.print("\n📤 [bold blue]Export Files Generated:[/bold blue]")
             for export_file in result.export_files:
@@ -561,16 +598,18 @@ class ExecutiveDashboardCreator:
 
 
 # Factory functions for easy integration
-def create_executive_dashboard_config(stakeholder_type: StakeholderType = StakeholderType.MANAGER,
-                                    optimization_target: float = 0.25,
-                                    export_formats: List[str] = None) -> BusinessConfiguration:
+def create_executive_dashboard_config(
+    stakeholder_type: StakeholderType = StakeholderType.MANAGER,
+    optimization_target: float = 0.25,
+    export_formats: List[str] = None,
+) -> BusinessConfiguration:
     """Factory function to create business configuration."""
     export_formats = export_formats or ["json", "csv", "html"]
     return BusinessConfiguration(
         stakeholder_type=stakeholder_type,
         optimization_target=optimization_target,
         export_formats=export_formats,
-        executive_reporting=True
+        executive_reporting=True,
     )
 
 
@@ -579,18 +618,17 @@ def get_executive_dashboard_creator(automation_engine: UniversalAutomationEngine
     return ExecutiveDashboardCreator(automation_engine)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Test executive dashboard creation
     import asyncio
-    
+
     async def test_dashboard():
         creator = ExecutiveDashboardCreator()
         config = create_executive_dashboard_config(StakeholderType.CFO)
-        
+
         result = await creator.create_executive_dashboard(
-            config=config,
-            optimization_focus=OptimizationCategory.COST_OPTIMIZATION
+            config=config, optimization_focus=OptimizationCategory.COST_OPTIMIZATION
         )
         console.print(f"Dashboard created with {len(result.export_files)} export files")
-    
-    asyncio.run(test_dashboard())
+
+    asyncio.run(test_dashboard())