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

runbooks/cloudops/base.py

@@ -23,23 +23,39 @@ from dataclasses import dataclass
 from datetime import datetime
 
 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 .models import (
-    BusinessScenario, ExecutionMode, RiskLevel, 
-    ProfileConfiguration, CloudOpsExecutionResult, BusinessMetrics, ResourceImpact
+    BusinessScenario,
+    ExecutionMode,
+    RiskLevel,
+    ProfileConfiguration,
+    CloudOpsExecutionResult,
+    BusinessMetrics,
+    ResourceImpact,
 )
 
+
 @dataclass
 class PerformanceBenchmark:
     """Performance benchmarking for enterprise operations."""
+
     operation_name: str
     start_time: float
     end_time: Optional[float] = None
     success: bool = True
     error_message: Optional[str] = None
-    
+
     @property
     def duration(self) -> float:
         """Calculate operation duration."""
@@ -47,10 +63,11 @@ class PerformanceBenchmark:
             return self.end_time - self.start_time
         return time.time() - self.start_time
 
+
 class CloudOpsBase:
     """
     Base class for all CloudOps automation scenarios.
-    
+
     Provides enterprise-grade functionality including:
     - Rich CLI integration with consistent UX
     - Performance monitoring and benchmarking
@@ -58,16 +75,13 @@ class CloudOpsBase:
     - Error handling with business-focused messaging
     - Audit trail and logging
     """
-    
+
     def __init__(
-        self, 
-        profile: str = "default", 
-        dry_run: bool = True,
-        execution_mode: ExecutionMode = ExecutionMode.DRY_RUN
+        self, profile: str = "default", dry_run: bool = True, execution_mode: ExecutionMode = ExecutionMode.DRY_RUN
     ):
         """
         Initialize CloudOps base class.
-        
+
         Args:
             profile: AWS profile name for operations
             dry_run: Enable dry-run mode (safe analysis only)
@@ -76,89 +90,81 @@ class CloudOpsBase:
         self.profile = profile
         self.dry_run = dry_run
         self.execution_mode = execution_mode
-        
+
         # Performance monitoring
         self.benchmarks: List[PerformanceBenchmark] = []
         self.session_start_time = time.time()
-        
+
         # AWS session management
         self.session: Optional[boto3.Session] = None
         self.available_regions: List[str] = []
-        
+
         # Business metrics collection
         self.resources_analyzed = 0
         self.resources_impacted: List[ResourceImpact] = []
-        
+
         # Initialize AWS session
         self._initialize_aws_session()
-        
+
     def _initialize_aws_session(self) -> None:
         """Initialize AWS session with profile validation."""
         try:
             self.session = boto3.Session(profile_name=self.profile)
-            
+
             # Validate session by getting caller identity
-            sts = self.session.client('sts')
+            sts = self.session.client("sts")
             identity = sts.get_caller_identity()
-            
-            self.account_id = identity.get('Account', 'unknown')
-            self.user_arn = identity.get('Arn', 'unknown')
-            
+
+            self.account_id = identity.get("Account", "unknown")
+            self.user_arn = identity.get("Arn", "unknown")
+
             print_success(f"AWS session initialized for profile: {self.profile}")
             print_info(f"Account ID: {self.account_id}")
-            
+
         except ProfileNotFound:
             error_msg = f"AWS profile '{self.profile}' not found in local configuration"
             print_error(error_msg)
             raise ValueError(error_msg)
-            
+
         except NoCredentialsError:
             error_msg = f"No valid credentials found for profile '{self.profile}'"
             print_error(error_msg)
             raise ValueError(error_msg)
-            
+
         except ClientError as e:
             error_msg = f"AWS authentication failed for profile '{self.profile}': {str(e)}"
             print_error(error_msg)
             raise ValueError(error_msg)
-    
-    def _get_available_regions(self, service_name: str = 'ec2') -> List[str]:
+
+    def _get_available_regions(self, service_name: str = "ec2") -> List[str]:
         """Get available AWS regions for a service."""
         if not self.available_regions:
             try:
-                client = self.session.client(service_name, region_name='us-east-1')
+                client = self.session.client(service_name, region_name="us-east-1")
                 response = client.describe_regions()
-                self.available_regions = [region['RegionName'] for region in response['Regions']]
+                self.available_regions = [region["RegionName"] for region in response["Regions"]]
             except Exception as e:
                 print_warning(f"Could not fetch available regions: {str(e)}")
                 # Fallback to common regions
-                self.available_regions = [
-                    'us-east-1', 'us-west-2', 'eu-west-1', 'ap-southeast-1'
-                ]
+                self.available_regions = ["us-east-1", "us-west-2", "eu-west-1", "ap-southeast-1"]
         return self.available_regions
-    
+
     def start_benchmark(self, operation_name: str) -> PerformanceBenchmark:
         """Start performance benchmarking for an operation."""
-        benchmark = PerformanceBenchmark(
-            operation_name=operation_name,
-            start_time=time.time()
-        )
+        benchmark = PerformanceBenchmark(operation_name=operation_name, start_time=time.time())
         self.benchmarks.append(benchmark)
         return benchmark
-    
+
     def complete_benchmark(
-        self, 
-        benchmark: PerformanceBenchmark, 
-        success: bool = True, 
-        error_message: Optional[str] = None
+        self, benchmark: PerformanceBenchmark, success: bool = True, error_message: Optional[str] = None
     ) -> None:
         """Complete performance benchmarking."""
         benchmark.end_time = time.time()
         benchmark.success = success
         benchmark.error_message = error_message
-        
+
         duration = benchmark.duration
-        
+
         # Rich CLI performance feedback
         if success:
             if duration < 30:  # < 30s target for single account
@@ -169,47 +175,41 @@ class CloudOpsBase:
                 print_error(f"⏰ {benchmark.operation_name} completed ({duration:.1f}s) - exceeds performance target")
         else:
             print_error(f"❌ {benchmark.operation_name} failed ({duration:.1f}s): {error_message}")
-    
-    async def execute_with_monitoring(
-        self, 
-        operation_name: str, 
-        operation_func,
-        *args, 
-        **kwargs
-    ) -> Any:
+
+    async def execute_with_monitoring(self, operation_name: str, operation_func, *args, **kwargs) -> Any:
         """
         Execute an operation with comprehensive monitoring.
-        
+
         Args:
             operation_name: Human-readable operation name
             operation_func: Async function to execute
             *args, **kwargs: Arguments to pass to operation_func
-            
+
         Returns:
             Result of operation_func execution
         """
         benchmark = self.start_benchmark(operation_name)
-        
+
         try:
             with console.status(f"[cyan]Executing {operation_name}..."):
                 if asyncio.iscoroutinefunction(operation_func):
                     result = await operation_func(*args, **kwargs)
                 else:
                     result = operation_func(*args, **kwargs)
-                
+
                 self.complete_benchmark(benchmark, success=True)
                 return result
-                
+
         except Exception as e:
             error_message = str(e)
             self.complete_benchmark(benchmark, success=False, error_message=error_message)
-            
+
             # Rich CLI error display
             print_error(f"Operation failed: {operation_name}")
             print_error(f"Error details: {error_message}")
-            
+
             raise
-    
+
     def create_resource_impact(
         self,
         resource_type: str,
@@ -219,11 +219,11 @@ class CloudOpsBase:
         projected_savings: Optional[float] = None,
         risk_level: RiskLevel = RiskLevel.LOW,
         modification_required: bool = False,
-        **kwargs
+        **kwargs,
     ) -> ResourceImpact:
         """
         Create a standardized ResourceImpact object.
-        
+
         Args:
             resource_type: AWS resource type (e.g., 'nat-gateway', 'ec2-instance')
             resource_id: Unique resource identifier
@@ -233,7 +233,7 @@ class CloudOpsBase:
             risk_level: Risk level for modification
             modification_required: Whether resource needs modification
             **kwargs: Additional ResourceImpact fields
-            
+
         Returns:
             ResourceImpact object with standardized business metrics
         """
@@ -246,18 +246,18 @@ class CloudOpsBase:
             projected_savings=projected_savings,
             risk_level=risk_level,
             modification_required=modification_required,
-            **kwargs
+            **kwargs,
         )
-        
+
         self.resources_impacted.append(impact)
         self.resources_analyzed += 1
-        
+
         return impact
-    
+
     def display_execution_summary(self, result: CloudOpsExecutionResult) -> None:
         """
         Display Rich CLI execution summary for business stakeholders.
-        
+
         Args:
             result: CloudOpsExecutionResult with business metrics
         """
@@ -269,17 +269,17 @@ class CloudOpsBase:
             f"⏱️  Execution Time: {result.execution_time:.1f}s\n"
             f"🛡️  Risk Level: {result.business_metrics.overall_risk_level.value.title()}"
         )
-        
+
         if result.business_metrics.roi_percentage:
             summary_content += f"\n📈 ROI: {result.business_metrics.roi_percentage:.1f}%"
-        
+
         summary_panel = create_panel(
             summary_content,
             title="Executive Business Impact Summary",
-            border_style="green" if result.success else "red"
+            border_style="green" if result.success else "red",
         )
         console.print(summary_panel)
-        
+
         # Performance Benchmarks Table
         if self.benchmarks:
             perf_table = create_table(
@@ -287,14 +287,14 @@ class CloudOpsBase:
                 columns=[
                     {"name": "Operation", "style": "cyan"},
                     {"name": "Duration", "style": "yellow"},
-                    {"name": "Status", "style": "green"}
-                ]
+                    {"name": "Status", "style": "green"},
+                ],
             )
-            
+
             for benchmark in self.benchmarks:
                 status_icon = "✅" if benchmark.success else "❌"
                 duration_str = f"{benchmark.duration:.1f}s"
-                
+
                 # Color code performance
                 if benchmark.duration < 30:
                     duration_style = "green"
@@ -302,51 +302,45 @@ class CloudOpsBase:
                     duration_style = "yellow"
                 else:
                     duration_style = "red"
-                
+
                 perf_table.add_row(
-                    benchmark.operation_name,
-                    f"[{duration_style}]{duration_str}[/{duration_style}]",
-                    status_icon
+                    benchmark.operation_name, f"[{duration_style}]{duration_str}[/{duration_style}]", status_icon
                 )
-            
+
             console.print(perf_table)
-        
+
         # Recommendations Display
         if result.recommendations:
             recommendations_text = "\n".join([f"• {rec}" for rec in result.recommendations])
-            rec_panel = create_panel(
-                recommendations_text,
-                title="Strategic Recommendations",
-                border_style="blue"
-            )
+            rec_panel = create_panel(recommendations_text, title="Strategic Recommendations", border_style="blue")
             console.print(rec_panel)
-    
+
     def create_business_metrics(
         self,
         total_savings: float = 0.0,
         implementation_cost: Optional[float] = None,
-        overall_risk: RiskLevel = RiskLevel.LOW
+        overall_risk: RiskLevel = RiskLevel.LOW,
     ) -> BusinessMetrics:
         """
         Create standardized business metrics for executive reporting.
-        
+
         Args:
             total_savings: Total projected monthly savings
             implementation_cost: One-time implementation cost
             overall_risk: Overall risk level for the operation
-            
+
         Returns:
             BusinessMetrics object with calculated ROI and business impact
         """
         # Calculate ROI if implementation cost is provided
         roi_percentage = None
         payback_period = None
-        
+
         if implementation_cost and implementation_cost > 0 and total_savings > 0:
             annual_savings = total_savings * 12
             roi_percentage = (annual_savings / implementation_cost - 1) * 100
             payback_period = int(implementation_cost / total_savings)
-        
+
         return BusinessMetrics(
             total_monthly_savings=total_savings,
             implementation_cost=implementation_cost,
@@ -355,7 +349,7 @@ class CloudOpsBase:
             overall_risk_level=overall_risk,
             operational_efficiency_gain=self._calculate_operational_efficiency_gain(total_savings),
             manual_effort_reduction=self._calculate_manual_effort_reduction(),
-            business_continuity_impact="minimal"
+            business_continuity_impact="minimal",
         )
 
     def _calculate_operational_efficiency_gain(self, total_savings: float) -> float:
@@ -369,7 +363,7 @@ class CloudOpsBase:
             Operational efficiency gain percentage
         """
         # Calculate efficiency based on actual operation benchmarks
-        if hasattr(self, 'benchmarks') and self.benchmarks:
+        if hasattr(self, "benchmarks") and self.benchmarks:
             # Calculate average improvement from successful operations
             successful_ops = [b for b in self.benchmarks if b.success]
             if successful_ops:
@@ -398,7 +392,7 @@ class CloudOpsBase:
         Returns:
             Manual effort reduction percentage
         """
-        if hasattr(self, 'benchmarks') and self.benchmarks:
+        if hasattr(self, "benchmarks") and self.benchmarks:
             # Calculate based on successful automated operations
             successful_ops = len([b for b in self.benchmarks if b.success])
             total_ops = len(self.benchmarks)
@@ -416,10 +410,10 @@ class CloudOpsBase:
         total_duration = time.time() - self.session_start_time
         successful_ops = sum(1 for b in self.benchmarks if b.success)
         failed_ops = len(self.benchmarks) - successful_ops
-        
+
         return {
             "profile_used": self.profile,
-            "account_id": getattr(self, 'account_id', 'unknown'),
+            "account_id": getattr(self, "account_id", "unknown"),
             "execution_mode": self.execution_mode.value,
             "total_session_duration": total_duration,
             "resources_analyzed": self.resources_analyzed,
@@ -427,12 +421,7 @@ class CloudOpsBase:
             "successful_operations": successful_ops,
             "failed_operations": failed_ops,
             "performance_benchmarks": [
-                {
-                    "operation": b.operation_name,
-                    "duration": b.duration,
-                    "success": b.success,
-                    "error": b.error_message
-                }
+                {"operation": b.operation_name, "duration": b.duration, "success": b.success, "error": b.error_message}
                 for b in self.benchmarks
-            ]
-        }
+            ],
+        }