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

runbooks/cloudops/notebook_framework.py

@@ -2,18 +2,18 @@
 """
 CloudOps Notebook Framework - Enterprise Consolidation Infrastructure
 
-Provides reusable components for consolidating 64 individual notebooks into 
+Provides reusable components for consolidating 64 individual notebooks into
 12-15 production scenarios with enterprise-grade functionality.
 
 Strategic Alignment:
-- Follows Rich CLI standards from rich_utils.py  
+- Follows Rich CLI standards from rich_utils.py
 - Handles authentication failures gracefully (no hardcoding/assumptions)
 - Dual-purpose interface: executive summary + technical details
 - Type-safe validation with Pydantic v2
 
 Key Features:
 - Authentication flow management with comprehensive error handling
-- Executive and technical reporting modes  
+- Executive and technical reporting modes
 - Multi-scenario consolidation support
 - MCP integration readiness
 - Performance monitoring and benchmarking
@@ -31,36 +31,60 @@ from enum import Enum
 import boto3
 import pandas as pd
 from botocore.exceptions import (
-    ClientError, NoCredentialsError, ProfileNotFound, 
-    TokenRetrievalError, UnauthorizedSSOTokenError
+    ClientError,
+    NoCredentialsError,
+    ProfileNotFound,
+    TokenRetrievalError,
+    UnauthorizedSSOTokenError,
 )
 from pydantic import BaseModel, Field, ValidationError
 
 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,
-    print_json, create_columns, confirm_action
+    console,
+    print_header,
+    print_success,
+    print_error,
+    print_warning,
+    print_info,
+    create_table,
+    create_progress_bar,
+    format_cost,
+    create_panel,
+    STATUS_INDICATORS,
+    print_json,
+    create_columns,
+    confirm_action,
 )
 from runbooks.common.profile_utils import (
-    get_profile_for_operation, create_cost_session, create_management_session,
-    create_operational_session
+    get_profile_for_operation,
+    create_cost_session,
+    create_management_session,
+    create_operational_session,
 )
 from .models import (
-    BusinessScenario, ExecutionMode, RiskLevel, ProfileConfiguration,
-    CloudOpsExecutionResult, BusinessMetrics, ResourceImpact, CostOptimizationResult
+    BusinessScenario,
+    ExecutionMode,
+    RiskLevel,
+    ProfileConfiguration,
+    CloudOpsExecutionResult,
+    BusinessMetrics,
+    ResourceImpact,
+    CostOptimizationResult,
 )
 from .base import CloudOpsBase, PerformanceBenchmark
 
 
 class NotebookMode(str, Enum):
     """Execution modes for notebook interface."""
+
     EXECUTIVE = "executive"  # Executive summary for business stakeholders
-    TECHNICAL = "technical"  # Technical details for engineering teams  
+    TECHNICAL = "technical"  # Technical details for engineering teams
     COMPREHENSIVE = "comprehensive"  # Both executive and technical views
 
 
 class AuthenticationStatus(str, Enum):
     """AWS authentication status tracking."""
+
     SUCCESS = "success"
     EXPIRED_TOKEN = "expired_token"
     INVALID_PROFILE = "invalid_profile"
@@ -72,12 +96,13 @@ class AuthenticationStatus(str, Enum):
 @dataclass
 class AuthenticationResult:
     """Results of AWS authentication validation."""
+
     status: AuthenticationStatus
     profile_name: str
     account_id: Optional[str] = None
     error_message: Optional[str] = None
     remediation_steps: List[str] = None
-    
+
     def __post_init__(self):
         if self.remediation_steps is None:
             self.remediation_steps = []
@@ -85,17 +110,18 @@ class AuthenticationResult:
 
 class ScenarioMetadata(BaseModel):
     """Metadata for consolidated notebook scenarios."""
+
     scenario_id: str = Field(description="Unique scenario identifier")
     scenario_name: str = Field(description="Human-readable scenario name")
     scenario_type: BusinessScenario = Field(description="Business scenario category")
     consolidated_notebooks: List[str] = Field(description="List of individual notebooks consolidated")
-    
+
     # Executive Information
     business_objective: str = Field(description="High-level business objective")
     expected_outcomes: List[str] = Field(description="Expected business outcomes")
     stakeholders: List[str] = Field(description="Key stakeholders", default=[])
-    
-    # Technical Information  
+
+    # Technical Information
     aws_services: List[str] = Field(description="AWS services utilized")
     estimated_execution_time: int = Field(description="Estimated execution time in minutes")
     prerequisites: List[str] = Field(description="Technical prerequisites", default=[])
@@ -104,21 +130,21 @@ class ScenarioMetadata(BaseModel):
 class NotebookFramework(CloudOpsBase):
     """
     Enterprise notebook framework for consolidated CloudOps scenarios.
-    
+
     Provides comprehensive infrastructure for transforming individual notebooks
     into enterprise-grade consolidated scenarios with dual executive/technical interfaces.
     """
-    
+
     def __init__(
-        self, 
+        self,
         profile: str = "default",
         mode: NotebookMode = NotebookMode.COMPREHENSIVE,
         dry_run: bool = True,
-        validate_auth: bool = True
+        validate_auth: bool = True,
     ):
         """
         Initialize notebook framework.
-        
+
         Args:
             profile: AWS profile for authentication
             mode: Notebook execution mode (executive/technical/comprehensive)
@@ -128,7 +154,7 @@ class NotebookFramework(CloudOpsBase):
         self.mode = mode
         self.validate_auth = validate_auth
         self.auth_status: Optional[AuthenticationResult] = None
-        
+
         # Initialize base class (handles AWS session setup)
         # Note: This may raise exceptions for authentication issues
         try:
@@ -141,14 +167,14 @@ class NotebookFramework(CloudOpsBase):
                 status=AuthenticationStatus.UNKNOWN_ERROR,
                 profile_name=profile,
                 error_message=str(e),
-                remediation_steps=self._get_generic_remediation_steps()
+                remediation_steps=self._get_generic_remediation_steps(),
             )
             self.session = None  # Ensure session is None on failure
-    
+
     def _validate_authentication(self) -> AuthenticationResult:
         """
         Comprehensive AWS authentication validation with detailed error handling.
-        
+
         Returns:
             AuthenticationResult with status and remediation guidance
         """
@@ -158,25 +184,23 @@ class NotebookFramework(CloudOpsBase):
                     status=AuthenticationStatus.NO_CREDENTIALS,
                     profile_name=self.profile,
                     error_message="No AWS session available",
-                    remediation_steps=self._get_generic_remediation_steps()
+                    remediation_steps=self._get_generic_remediation_steps(),
                 )
-            
+
             # Test authentication by calling STS
-            sts_client = self.session.client('sts')
+            sts_client = self.session.client("sts")
             identity = sts_client.get_caller_identity()
-            
-            account_id = identity.get('Account')
-            user_arn = identity.get('Arn')
-            
+
+            account_id = identity.get("Account")
+            user_arn = identity.get("Arn")
+
             print_success(f"Authentication successful for profile: {self.profile}")
             print_info(f"Account: {account_id}, Identity: {user_arn}")
-            
+
             return AuthenticationResult(
-                status=AuthenticationStatus.SUCCESS,
-                profile_name=self.profile,
-                account_id=account_id
+                status=AuthenticationStatus.SUCCESS, profile_name=self.profile, account_id=account_id
             )
-            
+
         except UnauthorizedSSOTokenError:
             return AuthenticationResult(
                 status=AuthenticationStatus.EXPIRED_TOKEN,
@@ -185,10 +209,10 @@ class NotebookFramework(CloudOpsBase):
                 remediation_steps=[
                     "Run: aws sso login",
                     "Ensure your AWS SSO session is active",
-                    f"Verify profile '{self.profile}' is configured for SSO"
-                ]
+                    f"Verify profile '{self.profile}' is configured for SSO",
+                ],
             )
-            
+
         except TokenRetrievalError as e:
             return AuthenticationResult(
                 status=AuthenticationStatus.EXPIRED_TOKEN,
@@ -197,10 +221,10 @@ class NotebookFramework(CloudOpsBase):
                 remediation_steps=[
                     "Run: aws sso login",
                     "Check your internet connection",
-                    "Verify AWS SSO configuration"
-                ]
+                    "Verify AWS SSO configuration",
+                ],
             )
-            
+
         except ProfileNotFound:
             return AuthenticationResult(
                 status=AuthenticationStatus.INVALID_PROFILE,
@@ -209,10 +233,10 @@ class NotebookFramework(CloudOpsBase):
                 remediation_steps=[
                     f"Check if profile '{self.profile}' exists in ~/.aws/config",
                     "Run: aws configure list-profiles",
-                    "Configure the profile using: aws configure sso"
-                ]
+                    "Configure the profile using: aws configure sso",
+                ],
             )
-            
+
         except NoCredentialsError:
             return AuthenticationResult(
                 status=AuthenticationStatus.NO_CREDENTIALS,
@@ -221,14 +245,14 @@ class NotebookFramework(CloudOpsBase):
                 remediation_steps=[
                     "Configure AWS credentials using: aws configure",
                     "Or set up SSO using: aws configure sso",
-                    "Verify AWS credentials are properly configured"
-                ]
+                    "Verify AWS credentials are properly configured",
+                ],
             )
-            
+
         except ClientError as e:
-            error_code = e.response.get('Error', {}).get('Code', 'Unknown')
-            
-            if error_code in ['AccessDenied', 'UnauthorizedOperation']:
+            error_code = e.response.get("Error", {}).get("Code", "Unknown")
+
+            if error_code in ["AccessDenied", "UnauthorizedOperation"]:
                 return AuthenticationResult(
                     status=AuthenticationStatus.PERMISSION_DENIED,
                     profile_name=self.profile,
@@ -236,113 +260,97 @@ class NotebookFramework(CloudOpsBase):
                     remediation_steps=[
                         "Verify your AWS profile has sufficient permissions",
                         "Contact your AWS administrator for access",
-                        "Check IAM policies attached to your role/user"
-                    ]
+                        "Check IAM policies attached to your role/user",
+                    ],
                 )
             else:
                 return AuthenticationResult(
                     status=AuthenticationStatus.UNKNOWN_ERROR,
                     profile_name=self.profile,
                     error_message=f"AWS API error: {str(e)}",
-                    remediation_steps=self._get_generic_remediation_steps()
+                    remediation_steps=self._get_generic_remediation_steps(),
                 )
-                
+
         except Exception as e:
             return AuthenticationResult(
                 status=AuthenticationStatus.UNKNOWN_ERROR,
                 profile_name=self.profile,
                 error_message=f"Unexpected error: {str(e)}",
-                remediation_steps=self._get_generic_remediation_steps()
+                remediation_steps=self._get_generic_remediation_steps(),
             )
-    
+
     def _get_generic_remediation_steps(self) -> List[str]:
         """Get generic remediation steps for authentication issues."""
         return [
             "Check AWS profile configuration: aws configure list-profiles",
             "Verify credentials: aws sts get-caller-identity",
-            "For SSO profiles, login again: aws sso login", 
-            "Contact your AWS administrator if issues persist"
+            "For SSO profiles, login again: aws sso login",
+            "Contact your AWS administrator if issues persist",
         ]
-    
+
     def display_authentication_status(self) -> None:
         """Display authentication status with Rich CLI formatting."""
         if not self.auth_status:
             print_warning("Authentication status not available")
             return
-        
+
         status_colors = {
             AuthenticationStatus.SUCCESS: "green",
             AuthenticationStatus.EXPIRED_TOKEN: "yellow",
             AuthenticationStatus.INVALID_PROFILE: "red",
-            AuthenticationStatus.NO_CREDENTIALS: "red", 
+            AuthenticationStatus.NO_CREDENTIALS: "red",
             AuthenticationStatus.PERMISSION_DENIED: "red",
-            AuthenticationStatus.UNKNOWN_ERROR: "red"
+            AuthenticationStatus.UNKNOWN_ERROR: "red",
         }
-        
+
         status_icons = {
             AuthenticationStatus.SUCCESS: "✅",
             AuthenticationStatus.EXPIRED_TOKEN: "⚠️",
             AuthenticationStatus.INVALID_PROFILE: "❌",
             AuthenticationStatus.NO_CREDENTIALS: "❌",
             AuthenticationStatus.PERMISSION_DENIED: "🔒",
-            AuthenticationStatus.UNKNOWN_ERROR: "❓"
+            AuthenticationStatus.UNKNOWN_ERROR: "❓",
         }
-        
+
         status_color = status_colors.get(self.auth_status.status, "white")
         status_icon = status_icons.get(self.auth_status.status, "?")
-        
+
         # Authentication Status Panel
         status_content = (
             f"Profile: {self.auth_status.profile_name}\n"
             f"Status: {status_icon} {self.auth_status.status.value.replace('_', ' ').title()}"
         )
-        
+
         if self.auth_status.account_id:
             status_content += f"\nAccount ID: {self.auth_status.account_id}"
-            
+
         if self.auth_status.error_message:
             status_content += f"\nError: {self.auth_status.error_message}"
-        
-        auth_panel = create_panel(
-            status_content,
-            title="AWS Authentication Status",
-            border_style=status_color
-        )
+
+        auth_panel = create_panel(status_content, title="AWS Authentication Status", border_style=status_color)
         console.print(auth_panel)
-        
+
         # Remediation Steps (if authentication failed)
-        if (self.auth_status.status != AuthenticationStatus.SUCCESS and 
-            self.auth_status.remediation_steps):
-            
+        if self.auth_status.status != AuthenticationStatus.SUCCESS and self.auth_status.remediation_steps:
             remediation_text = "\n".join([f"• {step}" for step in self.auth_status.remediation_steps])
-            remediation_panel = create_panel(
-                remediation_text,
-                title="Remediation Steps",
-                border_style="blue"
-            )
+            remediation_panel = create_panel(remediation_text, title="Remediation Steps", border_style="blue")
             console.print(remediation_panel)
-    
+
     def is_authenticated(self) -> bool:
         """Check if AWS authentication is successful."""
-        return (self.auth_status and 
-                self.auth_status.status == AuthenticationStatus.SUCCESS and
-                self.session is not None)
-    
-    def create_scenario_header(
-        self, 
-        metadata: ScenarioMetadata,
-        show_consolidated_info: bool = True
-    ) -> None:
+        return self.auth_status and self.auth_status.status == AuthenticationStatus.SUCCESS and self.session is not None
+
+    def create_scenario_header(self, metadata: ScenarioMetadata, show_consolidated_info: bool = True) -> None:
         """
         Create rich scenario header for consolidated notebooks.
-        
+
         Args:
             metadata: Scenario metadata with business and technical information
             show_consolidated_info: Show information about consolidated notebooks
         """
         # Main scenario header
         print_header(f"CloudOps Scenario: {metadata.scenario_name}", "latest version")
-        
+
         # Executive Summary (always shown)
         if self.mode in [NotebookMode.EXECUTIVE, NotebookMode.COMPREHENSIVE]:
             exec_content = (
@@ -351,55 +359,42 @@ class NotebookFramework(CloudOpsBase):
                 f"⏱️  Estimated Time: {metadata.estimated_execution_time} minutes\n"
                 f"🛡️  Execution Mode: {'🔍 Analysis Only' if self.dry_run else '⚡ Live Execution'}"
             )
-            
+
             if metadata.expected_outcomes:
                 exec_content += f"\n\n📈 Expected Outcomes:\n"
                 exec_content += "\n".join([f"• {outcome}" for outcome in metadata.expected_outcomes])
-            
-            exec_panel = create_panel(
-                exec_content,
-                title="Executive Summary",
-                border_style="cyan"
-            )
+
+            exec_panel = create_panel(exec_content, title="Executive Summary", border_style="cyan")
             console.print(exec_panel)
-        
+
         # Technical Details (technical/comprehensive modes)
         if self.mode in [NotebookMode.TECHNICAL, NotebookMode.COMPREHENSIVE]:
             tech_content = (
-                f"🔧 AWS Services: {', '.join(metadata.aws_services)}\n"
-                f"📝 Scenario ID: {metadata.scenario_id}"
+                f"🔧 AWS Services: {', '.join(metadata.aws_services)}\n📝 Scenario ID: {metadata.scenario_id}"
             )
-            
+
             if metadata.prerequisites:
                 tech_content += f"\n\n✅ Prerequisites:\n"
                 tech_content += "\n".join([f"• {prereq}" for prereq in metadata.prerequisites])
-            
+
             if show_consolidated_info and metadata.consolidated_notebooks:
                 tech_content += f"\n\n📚 Consolidated Notebooks ({len(metadata.consolidated_notebooks)}):\n"
                 tech_content += "\n".join([f"• {nb}" for nb in metadata.consolidated_notebooks])
-            
-            tech_panel = create_panel(
-                tech_content,
-                title="Technical Information",
-                border_style="blue"
-            )
+
+            tech_panel = create_panel(tech_content, title="Technical Information", border_style="blue")
             console.print(tech_panel)
-    
-    def create_results_summary(
-        self, 
-        result: CloudOpsExecutionResult,
-        show_detailed_metrics: bool = None
-    ) -> None:
+
+    def create_results_summary(self, result: CloudOpsExecutionResult, show_detailed_metrics: bool = None) -> None:
         """
         Create comprehensive results summary with mode-appropriate detail level.
-        
+
         Args:
             result: CloudOps execution result
             show_detailed_metrics: Override detail level (None = use mode default)
         """
         if show_detailed_metrics is None:
             show_detailed_metrics = self.mode in [NotebookMode.TECHNICAL, NotebookMode.COMPREHENSIVE]
-        
+
         # Executive Summary (always shown)
         exec_summary = (
             f"📊 Scenario: {result.scenario_name}\n"
@@ -409,20 +404,18 @@ class NotebookFramework(CloudOpsBase):
             f"💰 Monthly Savings: {format_cost(result.business_metrics.total_monthly_savings)}\n"
             f"⏱️  Execution Time: {result.execution_time:.1f}s"
         )
-        
+
         if result.business_metrics.roi_percentage:
             exec_summary += f"\n📈 ROI: {result.business_metrics.roi_percentage:.1f}%"
-        
+
         if not result.success and result.error_message:
             exec_summary += f"\n❌ Error: {result.error_message}"
-        
+
         exec_panel = create_panel(
-            exec_summary,
-            title="Execution Results Summary", 
-            border_style="green" if result.success else "red"
+            exec_summary, title="Execution Results Summary", border_style="green" if result.success else "red"
         )
         console.print(exec_panel)
-        
+
         # Detailed Metrics (technical/comprehensive modes)
         if show_detailed_metrics and result.business_metrics:
             metrics_table = create_table(
@@ -430,72 +423,54 @@ class NotebookFramework(CloudOpsBase):
                 columns=[
                     {"name": "Metric", "style": "cyan"},
                     {"name": "Value", "style": "green"},
-                    {"name": "Impact", "style": "yellow"}
-                ]
+                    {"name": "Impact", "style": "yellow"},
+                ],
             )
-            
+
             # Financial Metrics
             metrics_table.add_row(
-                "Monthly Savings",
-                f"${result.business_metrics.total_monthly_savings:,.2f}",
-                "Cost Reduction"
+                "Monthly Savings", f"${result.business_metrics.total_monthly_savings:,.2f}", "Cost Reduction"
             )
-            
+
             if result.business_metrics.roi_percentage:
                 metrics_table.add_row(
-                    "ROI Percentage", 
-                    f"{result.business_metrics.roi_percentage:.1f}%",
-                    "Investment Return"
+                    "ROI Percentage", f"{result.business_metrics.roi_percentage:.1f}%", "Investment Return"
                 )
-            
+
             if result.business_metrics.payback_period_months:
                 metrics_table.add_row(
-                    "Payback Period",
-                    f"{result.business_metrics.payback_period_months} months",
-                    "Investment Recovery"
+                    "Payback Period", f"{result.business_metrics.payback_period_months} months", "Investment Recovery"
                 )
-            
+
             # Operational Metrics
             if result.business_metrics.operational_efficiency_gain:
                 metrics_table.add_row(
                     "Efficiency Gain",
                     f"{result.business_metrics.operational_efficiency_gain:.1f}%",
-                    "Operational Improvement"
+                    "Operational Improvement",
                 )
-            
+
             metrics_table.add_row(
-                "Risk Level",
-                result.business_metrics.overall_risk_level.value.title(),
-                "Risk Assessment"
+                "Risk Level", result.business_metrics.overall_risk_level.value.title(), "Risk Assessment"
             )
-            
+
             console.print(metrics_table)
-        
+
         # Recommendations (always shown if present)
         if result.recommendations:
             rec_text = "\n".join([f"• {rec}" for rec in result.recommendations])
-            rec_panel = create_panel(
-                rec_text,
-                title="Strategic Recommendations",
-                border_style="blue"
-            )
+            rec_panel = create_panel(rec_text, title="Strategic Recommendations", border_style="blue")
             console.print(rec_panel)
-    
-    async def execute_with_auth_handling(
-        self,
-        operation_name: str,
-        operation_func: Callable,
-        *args,
-        **kwargs
-    ) -> Any:
+
+    async def execute_with_auth_handling(self, operation_name: str, operation_func: Callable, *args, **kwargs) -> Any:
         """
         Execute operation with comprehensive authentication error handling.
-        
+
         Args:
             operation_name: Human-readable operation name
             operation_func: Function to execute (sync or async)
             *args, **kwargs: Arguments for operation_func
-            
+
         Returns:
             Operation result or None if authentication failed
         """
@@ -504,101 +479,96 @@ class NotebookFramework(CloudOpsBase):
             print_error(f"Cannot execute {operation_name}: Authentication failed")
             self.display_authentication_status()
             return None
-        
+
         # Execute with monitoring (from CloudOpsBase)
         try:
-            return await self.execute_with_monitoring(
-                operation_name, operation_func, *args, **kwargs
-            )
+            return await self.execute_with_monitoring(operation_name, operation_func, *args, **kwargs)
         except ClientError as e:
-            error_code = e.response.get('Error', {}).get('Code', 'Unknown')
-            
-            if error_code in ['ExpiredToken', 'InvalidToken']:
+            error_code = e.response.get("Error", {}).get("Code", "Unknown")
+
+            if error_code in ["ExpiredToken", "InvalidToken"]:
                 print_error(f"AWS token expired during {operation_name}")
                 print_warning("Please refresh your AWS credentials and retry")
                 return None
-            elif error_code in ['AccessDenied', 'UnauthorizedOperation']:
+            elif error_code in ["AccessDenied", "UnauthorizedOperation"]:
                 print_error(f"Permission denied during {operation_name}")
                 print_info("Contact your AWS administrator for required permissions")
                 return None
             else:
                 # Re-raise other AWS errors
                 raise
-    
+
     def export_results_to_formats(
-        self,
-        result: CloudOpsExecutionResult,
-        export_dir: Path = None,
-        formats: List[str] = None
+        self, result: CloudOpsExecutionResult, export_dir: Path = None, formats: List[str] = None
     ) -> Dict[str, str]:
         """
         Export results to multiple formats for enterprise reporting.
-        
+
         Args:
             result: Execution result to export
             export_dir: Directory for exported files (default: ./exports)
             formats: List of formats ['json', 'csv', 'html', 'pdf'] (default: all)
-            
+
         Returns:
             Dictionary mapping format to file path
         """
         if export_dir is None:
             export_dir = Path("./exports")
-        
+
         if formats is None:
-            formats = ['json', 'csv', 'html']  # PDF requires additional dependencies
-        
+            formats = ["json", "csv", "html"]  # PDF requires additional dependencies
+
         export_dir.mkdir(exist_ok=True)
         exported_files = {}
-        
+
         # Base filename
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         base_filename = f"{result.scenario.value}_{timestamp}"
-        
+
         # JSON Export
-        if 'json' in formats:
+        if "json" in formats:
             json_file = export_dir / f"{base_filename}.json"
-            with open(json_file, 'w') as f:
+            with open(json_file, "w") as f:
                 json.dump(result.dict(), f, indent=2, default=str)
-            exported_files['json'] = str(json_file)
+            exported_files["json"] = str(json_file)
             print_success(f"JSON export: {json_file}")
-        
+
         # CSV Export (summary metrics)
-        if 'csv' in formats:
+        if "csv" in formats:
             csv_file = export_dir / f"{base_filename}_summary.csv"
             summary_df = pd.DataFrame([result.summary_metrics])
             summary_df.to_csv(csv_file, index=False)
-            exported_files['csv'] = str(csv_file)
+            exported_files["csv"] = str(csv_file)
             print_success(f"CSV export: {csv_file}")
-            
+
             # Resource impacts CSV
             if result.resources_impacted:
                 impacts_csv = export_dir / f"{base_filename}_impacts.csv"
                 impacts_data = [impact.dict() for impact in result.resources_impacted]
                 impacts_df = pd.DataFrame(impacts_data)
                 impacts_df.to_csv(impacts_csv, index=False)
-                exported_files['csv_impacts'] = str(impacts_csv)
+                exported_files["csv_impacts"] = str(impacts_csv)
                 print_info(f"Resource impacts CSV: {impacts_csv}")
-        
+
         # HTML Export (Rich console output)
-        if 'html' in formats:
+        if "html" in formats:
             html_file = export_dir / f"{base_filename}.html"
             # Create HTML version of the results
             html_content = self._create_html_report(result)
-            with open(html_file, 'w') as f:
+            with open(html_file, "w") as f:
                 f.write(html_content)
-            exported_files['html'] = str(html_file)
+            exported_files["html"] = str(html_file)
             print_success(f"HTML export: {html_file}")
-        
+
         return exported_files
-    
+
     def _create_html_report(self, result: CloudOpsExecutionResult) -> str:
         """
         Create HTML report from execution result.
-        
+
         Args:
             result: Execution result
-            
+
         Returns:
             HTML content string
         """
@@ -626,8 +596,8 @@ class NotebookFramework(CloudOpsBase):
                 <p><strong>Scenario:</strong> {result.scenario_name}</p>
                 <p><strong>Execution Time:</strong> {result.execution_time:.1f} seconds</p>
                 <p><strong>Status:</strong> 
-                    <span class="{'success' if result.success else 'error'}">
-                        {'✅ Success' if result.success else '❌ Failed'}
+                    <span class="{"success" if result.success else "error"}">
+                        {"✅ Success" if result.success else "❌ Failed"}
                     </span>
                 </p>
                 <p><strong>Resources Analyzed:</strong> {result.resources_analyzed:,}</p>
@@ -667,10 +637,4 @@ class NotebookFramework(CloudOpsBase):
 
 
 # Export framework components
-__all__ = [
-    "NotebookFramework",
-    "NotebookMode", 
-    "AuthenticationStatus",
-    "AuthenticationResult",
-    "ScenarioMetadata"
-]
+__all__ = ["NotebookFramework", "NotebookMode", "AuthenticationStatus", "AuthenticationResult", "ScenarioMetadata"]