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

runbooks/common/business_logic.py

@@ -13,22 +13,31 @@ from dataclasses import dataclass, field
 from enum import Enum
 
 from .rich_utils import (
-    create_table, console, print_header, print_success, print_info,
-    print_warning, format_cost, create_panel, create_progress_bar
+    create_table,
+    console,
+    print_header,
+    print_success,
+    print_info,
+    print_warning,
+    format_cost,
+    create_panel,
+    create_progress_bar,
 )
 from .profile_utils import get_profile_for_operation
 
 
 class BusinessImpactLevel(Enum):
     """Business impact classification for operations and optimizations."""
+
     CRITICAL = "CRITICAL"  # >$100K annual impact
-    HIGH = "HIGH"         # measurable range annual impact
-    MEDIUM = "MEDIUM"     # measurable range annual impact
-    LOW = "LOW"          # <$5K annual impact
+    HIGH = "HIGH"  # measurable range annual impact
+    MEDIUM = "MEDIUM"  # measurable range annual impact
+    LOW = "LOW"  # <$5K annual impact
 
 
 class OptimizationType(Enum):
     """Types of optimization operations supported."""
+
     COST_REDUCTION = "COST_REDUCTION"
     RESOURCE_EFFICIENCY = "RESOURCE_EFFICIENCY"
     SECURITY_COMPLIANCE = "SECURITY_COMPLIANCE"
@@ -39,6 +48,7 @@ class OptimizationType(Enum):
 @dataclass
 class BusinessMetrics:
     """Universal business metrics for operations and optimizations."""
+
     annual_savings: float = 0.0
     monthly_cost_current: float = 0.0
     monthly_cost_optimized: float = 0.0
@@ -70,6 +80,7 @@ class BusinessMetrics:
 @dataclass
 class OptimizationResult:
     """Universal optimization result structure."""
+
     resource_type: str
     operation_type: OptimizationType
     business_metrics: BusinessMetrics
@@ -101,8 +112,9 @@ class UniversalBusinessLogic:
         self.module_name = module_name
         self.session_metrics = []
 
-    def create_cost_analysis_table(self, cost_data: Dict[str, Any], title: str,
-                                 include_quarterly: bool = False) -> None:
+    def create_cost_analysis_table(
+        self, cost_data: Dict[str, Any], title: str, include_quarterly: bool = False
+    ) -> None:
         """
         Standardized cost analysis table creation following FinOps patterns.
 
@@ -111,10 +123,7 @@ class UniversalBusinessLogic:
             title: Table title for display
             include_quarterly: Include quarterly intelligence columns
         """
-        table = create_table(
-            title=title,
-            caption="Enterprise cost analysis with MCP validation"
-        )
+        table = create_table(title=title, caption="Enterprise cost analysis with MCP validation")
 
         # Standard columns based on successful FinOps patterns
         table.add_column("Resource", style="cyan", no_wrap=True)
@@ -129,21 +138,16 @@ class UniversalBusinessLogic:
         # Add rows with consistent formatting
         total_savings = 0.0
         for resource, data in cost_data.items():
-            current_cost = data.get('current', 0.0)
-            optimization_pct = data.get('optimization_percentage', 0.0)
-            annual_savings = data.get('annual_savings', 0.0)
+            current_cost = data.get("current", 0.0)
+            optimization_pct = data.get("optimization_percentage", 0.0)
+            annual_savings = data.get("annual_savings", 0.0)
             total_savings += annual_savings
 
-            row_data = [
-                resource,
-                format_cost(current_cost),
-                f"{optimization_pct:.1f}%",
-                format_cost(annual_savings)
-            ]
+            row_data = [resource, format_cost(current_cost), f"{optimization_pct:.1f}%", format_cost(annual_savings)]
 
             if include_quarterly:
-                quarterly_trend = data.get('quarterly_trend', 'Stable')
-                strategic_context = data.get('strategic_context', 'Monitor')
+                quarterly_trend = data.get("quarterly_trend", "Stable")
+                strategic_context = data.get("strategic_context", "Monitor")
                 row_data.extend([quarterly_trend, strategic_context])
 
             table.add_row(*row_data)
@@ -163,17 +167,14 @@ class UniversalBusinessLogic:
 [bold bright_green]Total Annual Savings: {format_cost(total_savings)}[/]
 [yellow]Business Impact: {impact_level.value}[/]
 [cyan]Resources Analyzed: {len(cost_data)}[/]
-[dim]Analysis Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}[/]
+[dim]Analysis Timestamp: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}[/]
             """
-            summary_panel = create_panel(
-                summary_text.strip(),
-                title="💰 Executive Summary",
-                border_style="green"
-            )
+            summary_panel = create_panel(summary_text.strip(), title="💰 Executive Summary", border_style="green")
             console.print(summary_panel)
 
-    def standardize_resource_operations(self, resource_type: str, operation: str,
-                                      profile: Optional[str] = None, **kwargs) -> Dict[str, Any]:
+    def standardize_resource_operations(
+        self, resource_type: str, operation: str, profile: Optional[str] = None, **kwargs
+    ) -> Dict[str, Any]:
         """
         Standardized resource operation pattern following proven CLI patterns.
 
@@ -197,19 +198,16 @@ class UniversalBusinessLogic:
 
         # Standard result format following successful patterns
         result = {
-            'module': self.module_name,
-            'resource_type': resource_type,
-            'operation': operation,
-            'profile_used': selected_profile,
-            'timestamp': operation_start.isoformat(),
-            'success': True,
-            'results': {},
-            'business_metrics': BusinessMetrics(),
-            'recommendations': [],
-            'performance_data': {
-                'start_time': operation_start.isoformat(),
-                'execution_time_seconds': 0.0
-            }
+            "module": self.module_name,
+            "resource_type": resource_type,
+            "operation": operation,
+            "profile_used": selected_profile,
+            "timestamp": operation_start.isoformat(),
+            "success": True,
+            "results": {},
+            "business_metrics": BusinessMetrics(),
+            "recommendations": [],
+            "performance_data": {"start_time": operation_start.isoformat(), "execution_time_seconds": 0.0},
         }
 
         return result
@@ -230,30 +228,38 @@ class UniversalBusinessLogic:
 
         # Impact-based recommendations
         if impact == BusinessImpactLevel.CRITICAL:
-            recommendations.extend([
-                f"🚨 CRITICAL: Immediate action required - ${metrics.annual_savings:,.0f} annual savings opportunity",
-                "📋 Executive approval recommended for implementation",
-                "⏰ Target implementation: Within 30 days",
-                "📊 Monthly progress tracking recommended"
-            ])
+            recommendations.extend(
+                [
+                    f"🚨 CRITICAL: Immediate action required - ${metrics.annual_savings:,.0f} annual savings opportunity",
+                    "📋 Executive approval recommended for implementation",
+                    "⏰ Target implementation: Within 30 days",
+                    "📊 Monthly progress tracking recommended",
+                ]
+            )
         elif impact == BusinessImpactLevel.HIGH:
-            recommendations.extend([
-                f"🔴 HIGH PRIORITY: ${metrics.annual_savings:,.0f} annual savings available",
-                "📋 Business case development recommended",
-                "⏰ Target implementation: Within 90 days",
-                "📊 Quarterly progress review recommended"
-            ])
+            recommendations.extend(
+                [
+                    f"🔴 HIGH PRIORITY: ${metrics.annual_savings:,.0f} annual savings available",
+                    "📋 Business case development recommended",
+                    "⏰ Target implementation: Within 90 days",
+                    "📊 Quarterly progress review recommended",
+                ]
+            )
         elif impact == BusinessImpactLevel.MEDIUM:
-            recommendations.extend([
-                f"🟡 MEDIUM PRIORITY: ${metrics.annual_savings:,.0f} annual savings potential",
-                "📋 Consider in next planning cycle",
-                "⏰ Target implementation: Within 6 months"
-            ])
+            recommendations.extend(
+                [
+                    f"🟡 MEDIUM PRIORITY: ${metrics.annual_savings:,.0f} annual savings potential",
+                    "📋 Consider in next planning cycle",
+                    "⏰ Target implementation: Within 6 months",
+                ]
+            )
         else:
-            recommendations.extend([
-                f"🟢 LOW PRIORITY: ${metrics.annual_savings:,.0f} annual savings",
-                "📋 Include in routine optimization reviews"
-            ])
+            recommendations.extend(
+                [
+                    f"🟢 LOW PRIORITY: ${metrics.annual_savings:,.0f} annual savings",
+                    "📋 Include in routine optimization reviews",
+                ]
+            )
 
         # ROI-based recommendations
         if metrics.roi_percentage > 200:
@@ -271,8 +277,9 @@ class UniversalBusinessLogic:
 
         return recommendations
 
-    def create_executive_dashboard(self, results: List[OptimizationResult],
-                                 dashboard_title: str = "Executive Dashboard") -> None:
+    def create_executive_dashboard(
+        self, results: List[OptimizationResult], dashboard_title: str = "Executive Dashboard"
+    ) -> None:
         """
         Create executive dashboard following successful FinOps patterns.
 
@@ -288,7 +295,14 @@ class UniversalBusinessLogic:
 
         # Summary metrics
         total_savings = sum(r.business_metrics.annual_savings for r in results)
-        high_impact_count = len([r for r in results if r.business_metrics.determine_impact_level() in [BusinessImpactLevel.CRITICAL, BusinessImpactLevel.HIGH]])
+        high_impact_count = len(
+            [
+                r
+                for r in results
+                if r.business_metrics.determine_impact_level()
+                in [BusinessImpactLevel.CRITICAL, BusinessImpactLevel.HIGH]
+            ]
+        )
 
         # Executive summary table
         summary_table = create_table(
@@ -296,13 +310,17 @@ class UniversalBusinessLogic:
             columns=[
                 {"name": "Metric", "style": "cyan", "justify": "left"},
                 {"name": "Value", "style": "bright_green", "justify": "right"},
-                {"name": "Impact", "style": "yellow", "justify": "left"}
-            ]
+                {"name": "Impact", "style": "yellow", "justify": "left"},
+            ],
         )
 
         summary_table.add_row("Total Annual Savings", format_cost(total_savings), f"{len(results)} opportunities")
         summary_table.add_row("High Priority Items", str(high_impact_count), "Immediate attention required")
-        summary_table.add_row("Average Confidence", f"{sum(r.business_metrics.confidence_level for r in results) / len(results):.1f}%", "Validation accuracy")
+        summary_table.add_row(
+            "Average Confidence",
+            f"{sum(r.business_metrics.confidence_level for r in results) / len(results):.1f}%",
+            "Validation accuracy",
+        )
 
         console.print(summary_table)
 
@@ -318,8 +336,8 @@ class UniversalBusinessLogic:
                     {"name": "Annual Savings", "style": "bright_green", "justify": "right"},
                     {"name": "Impact", "style": "yellow", "justify": "center"},
                     {"name": "Confidence", "style": "blue", "justify": "right"},
-                    {"name": "Next Action", "style": "white", "justify": "left"}
-                ]
+                    {"name": "Next Action", "style": "white", "justify": "left"},
+                ],
             )
 
             for result in top_results:
@@ -331,7 +349,7 @@ class UniversalBusinessLogic:
                     format_cost(result.business_metrics.annual_savings),
                     impact.value,
                     f"{result.business_metrics.confidence_level:.1f}%",
-                    next_action
+                    next_action,
                 )
 
             console.print(opportunities_table)
@@ -350,8 +368,8 @@ class UniversalBusinessLogic:
         metrics = BusinessMetrics()
 
         # Extract costs
-        current_monthly = usage_data.get('monthly_cost_current', 0.0)
-        optimized_monthly = usage_data.get('monthly_cost_optimized', current_monthly * 0.7)  # Default 30% optimization
+        current_monthly = usage_data.get("monthly_cost_current", 0.0)
+        optimized_monthly = usage_data.get("monthly_cost_optimized", current_monthly * 0.7)  # Default 30% optimization
 
         metrics.monthly_cost_current = current_monthly
         metrics.monthly_cost_optimized = optimized_monthly
@@ -362,12 +380,12 @@ class UniversalBusinessLogic:
 
         # Set confidence based on resource type (following successful patterns)
         confidence_levels = {
-            'NAT Gateway': 95.0,  # High confidence from proven results
-            'Elastic IP': 90.0,
-            'EBS Volume': 85.0,
-            'EC2 Instance': 80.0,
-            'RDS Instance': 75.0,
-            'Generic': 70.0
+            "NAT Gateway": 95.0,  # High confidence from proven results
+            "Elastic IP": 90.0,
+            "EBS Volume": 85.0,
+            "EC2 Instance": 80.0,
+            "RDS Instance": 75.0,
+            "Generic": 70.0,
         }
         metrics.confidence_level = confidence_levels.get(resource_type, 70.0)
 
@@ -384,8 +402,9 @@ class UniversalBusinessLogic:
 
         return metrics
 
-    def export_business_results(self, results: List[OptimizationResult],
-                               export_formats: List[str] = None) -> Dict[str, str]:
+    def export_business_results(
+        self, results: List[OptimizationResult], export_formats: List[str] = None
+    ) -> Dict[str, str]:
         """
         Export business results in multiple formats following successful patterns.
 
@@ -397,9 +416,9 @@ class UniversalBusinessLogic:
             Dictionary with export file paths
         """
         if export_formats is None:
-            export_formats = ['csv', 'json', 'markdown']
+            export_formats = ["csv", "json", "markdown"]
 
-        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         base_filename = f"{self.module_name}_optimization_results_{timestamp}"
 
         exported_files = {}
@@ -409,41 +428,44 @@ class UniversalBusinessLogic:
         for fmt in export_formats:
             filename = f"./awso_evidence/{base_filename}.{fmt}"
 
-            if fmt == 'csv':
+            if fmt == "csv":
                 # CSV export for analysis
                 csv_content = "Resource,Annual_Savings,Impact_Level,Confidence,ROI_Percentage\n"
                 for result in results:
                     csv_content += f"{result.resource_type},{result.business_metrics.annual_savings},"
                     csv_content += f"{result.business_metrics.determine_impact_level().value},"
-                    csv_content += f"{result.business_metrics.confidence_level},{result.business_metrics.roi_percentage}\n"
+                    csv_content += (
+                        f"{result.business_metrics.confidence_level},{result.business_metrics.roi_percentage}\n"
+                    )
 
-                with open(filename, 'w') as f:
+                with open(filename, "w") as f:
                     f.write(csv_content)
 
-            elif fmt == 'json':
+            elif fmt == "json":
                 # JSON export for systems integration
                 import json
+
                 json_data = {
-                    'module': self.module_name,
-                    'timestamp': timestamp,
-                    'total_results': len(results),
-                    'total_annual_savings': sum(r.business_metrics.annual_savings for r in results),
-                    'results': [
+                    "module": self.module_name,
+                    "timestamp": timestamp,
+                    "total_results": len(results),
+                    "total_annual_savings": sum(r.business_metrics.annual_savings for r in results),
+                    "results": [
                         {
-                            'resource_type': r.resource_type,
-                            'annual_savings': r.business_metrics.annual_savings,
-                            'impact_level': r.business_metrics.determine_impact_level().value,
-                            'confidence_level': r.business_metrics.confidence_level,
-                            'executive_summary': r.get_executive_summary()
+                            "resource_type": r.resource_type,
+                            "annual_savings": r.business_metrics.annual_savings,
+                            "impact_level": r.business_metrics.determine_impact_level().value,
+                            "confidence_level": r.business_metrics.confidence_level,
+                            "executive_summary": r.get_executive_summary(),
                         }
                         for r in results
-                    ]
+                    ],
                 }
 
-                with open(filename, 'w') as f:
+                with open(filename, "w") as f:
                     json.dump(json_data, f, indent=2)
 
-            elif fmt == 'markdown':
+            elif fmt == "markdown":
                 # Markdown export for documentation and reports
                 md_content = f"# {self.module_name.title()} Optimization Results\n\n"
                 md_content += f"**Generated**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
@@ -462,7 +484,7 @@ class UniversalBusinessLogic:
                     md_content += f"- **Confidence**: {result.business_metrics.confidence_level:.1f}%\n"
                     md_content += f"- **ROI**: {result.business_metrics.roi_percentage:.1f}%\n\n"
 
-                with open(filename, 'w') as f:
+                with open(filename, "w") as f:
                     f.write(md_content)
 
             exported_files[fmt] = filename
@@ -482,4 +504,4 @@ def create_business_logic_handler(module_name: str) -> UniversalBusinessLogic:
     Returns:
         UniversalBusinessLogic instance configured for the module
     """
-    return UniversalBusinessLogic(module_name)
+    return UniversalBusinessLogic(module_name)

runbooks/common/cli_decorators.py

@@ -27,26 +27,19 @@ def common_aws_options(f: Callable) -> Callable:
         def my_command(profile, region, dry_run, **kwargs):
             # Your command logic here
     """
+
+    @click.option("--profile", help="AWS profile override (highest priority over environment variables)", type=str)
+    @click.option("--region", help="AWS region override (default: us-east-1)", type=str, default="us-east-1")
     @click.option(
-        '--profile',
-        help='AWS profile override (highest priority over environment variables)',
-        type=str
-    )
-    @click.option(
-        '--region',
-        help='AWS region override (default: us-east-1)',
-        type=str,
-        default='us-east-1'
-    )
-    @click.option(
-        '--dry-run',
+        "--dry-run",
         is_flag=True,
         default=True,
-        help='Safe analysis mode - no resource modifications (enterprise default)'
+        help="Safe analysis mode - no resource modifications (enterprise default)",
     )
     @wraps(f)
     def wrapper(*args, **kwargs):
         return f(*args, **kwargs)
+
     return wrapper
 
 
@@ -65,26 +58,24 @@ def common_output_options(f: Callable) -> Callable:
         def my_command(output_format, output_dir, export, **kwargs):
             # Your command logic here
     """
+
     @click.option(
-        '--output-format',
-        type=click.Choice(['json', 'csv', 'table', 'pdf', 'markdown'], case_sensitive=False),
-        default='table',
-        help='Output format for results display'
-    )
-    @click.option(
-        '--output-dir',
-        default='./awso_evidence',
-        help='Directory for generated files and evidence packages',
-        type=click.Path()
+        "--output-format",
+        type=click.Choice(["json", "csv", "table", "pdf", "markdown"], case_sensitive=False),
+        default="table",
+        help="Output format for results display",
     )
     @click.option(
-        '--export',
-        is_flag=True,
-        help='Enable multi-format export (CSV, JSON, PDF, HTML)'
+        "--output-dir",
+        default="./awso_evidence",
+        help="Directory for generated files and evidence packages",
+        type=click.Path(),
     )
+    @click.option("--export", is_flag=True, help="Enable multi-format export (CSV, JSON, PDF, HTML)")
     @wraps(f)
     def wrapper(*args, **kwargs):
         return f(*args, **kwargs)
+
     return wrapper
 
 
@@ -102,20 +93,18 @@ def mcp_validation_option(f: Callable) -> Callable:
         def my_command(validate, confidence_threshold, **kwargs):
             # Your command logic with MCP validation
     """
+
+    @click.option("--validate", is_flag=True, help="Enable MCP validation for enhanced accuracy (≥99.5% target)")
     @click.option(
-        '--validate',
-        is_flag=True,
-        help='Enable MCP validation for enhanced accuracy (≥99.5% target)'
-    )
-    @click.option(
-        '--confidence-threshold',
+        "--confidence-threshold",
         type=float,
         default=99.5,
-        help='Minimum confidence threshold for validation (default: 99.5%%)'
+        help="Minimum confidence threshold for validation (default: 99.5%%)",
     )
     @wraps(f)
     def wrapper(*args, **kwargs):
         return f(*args, **kwargs)
+
     return wrapper
 
 
@@ -134,26 +123,21 @@ def enterprise_options(f: Callable) -> Callable:
         def my_command(all_profiles, combine, approval_required, **kwargs):
             # Your enterprise command logic
     """
+
     @click.option(
-        '--all',
-        'all_profiles',
-        is_flag=True,
-        help='Use all available AWS profiles for multi-account operations'
-    )
-    @click.option(
-        '--combine',
-        is_flag=True,
-        help='Combine profiles from the same AWS account for unified reporting'
+        "--all", "all_profiles", is_flag=True, help="Use all available AWS profiles for multi-account operations"
     )
+    @click.option("--combine", is_flag=True, help="Combine profiles from the same AWS account for unified reporting")
     @click.option(
-        '--approval-required',
+        "--approval-required",
         is_flag=True,
         default=True,
-        help='Require human approval for state-changing operations (enterprise default)'
+        help="Require human approval for state-changing operations (enterprise default)",
     )
     @wraps(f)
     def wrapper(*args, **kwargs):
         return f(*args, **kwargs)
+
     return wrapper
 
 
@@ -172,26 +156,16 @@ def performance_options(f: Callable) -> Callable:
         def my_command(performance_target, timeout, parallel, **kwargs):
             # Your performance-monitored command
     """
+
     @click.option(
-        '--performance-target',
-        type=int,
-        default=30,
-        help='Target execution time in seconds (enterprise default: 30s)'
-    )
-    @click.option(
-        '--timeout',
-        type=int,
-        default=300,
-        help='Maximum execution timeout in seconds (default: 5 minutes)'
-    )
-    @click.option(
-        '--parallel',
-        is_flag=True,
-        help='Enable parallel processing for multi-resource operations'
+        "--performance-target", type=int, default=30, help="Target execution time in seconds (enterprise default: 30s)"
     )
+    @click.option("--timeout", type=int, default=300, help="Maximum execution timeout in seconds (default: 5 minutes)")
+    @click.option("--parallel", is_flag=True, help="Enable parallel processing for multi-resource operations")
     @wraps(f)
     def wrapper(*args, **kwargs):
         return f(*args, **kwargs)
+
     return wrapper
 
 
@@ -208,6 +182,7 @@ def all_standard_options(f: Callable) -> Callable:
         def comprehensive_command(**kwargs):
             # Command with all standard options available
     """
+
     @performance_options
     @enterprise_options
     @mcp_validation_option
@@ -216,4 +191,5 @@ def all_standard_options(f: Callable) -> Callable:
     @wraps(f)
     def wrapper(*args, **kwargs):
         return f(*args, **kwargs)
-    return wrapper
+
+    return wrapper