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

runbooks/finops/enterprise_wrappers.py

@@ -2,7 +2,7 @@
 🏗️ CloudOps-Automation Enterprise Wrappers Module
 Enterprise-Specific Pattern Implementations for CloudOps Consolidation
 
-Strategic Achievement: Enterprise wrapper patterns enabling seamless integration 
+Strategic Achievement: Enterprise wrapper patterns enabling seamless integration
 of 67+ legacy notebooks into unified modular architecture with FAANG naming conventions.
 
 Module Focus: Provide enterprise-specific wrappers and integration patterns that
@@ -16,34 +16,42 @@ Key Features:
 - Enterprise CLI wrapper interfaces
 - Business stakeholder interface adapters
 
-Author: Enterprise Agile Team (6-Agent Coordination)  
+Author: Enterprise Agile Team (6-Agent Coordination)
 Version: latest version - Distributed Architecture Framework
 """
 
-import os
 import json
-from typing import Dict, List, Optional, Any, Union, Callable
+import os
+from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from enum import Enum
 from datetime import datetime
-from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional, Union
 
 from ..common.rich_utils import (
-    console, print_header, print_success, print_warning, print_error,
-    create_table, create_progress_bar, format_cost
+    console,
+    create_progress_bar,
+    create_table,
+    format_cost,
+    print_error,
+    print_header,
+    print_success,
+    print_warning,
 )
 
 
 class EnterpriseSize(Enum):
     """Enterprise size classification for wrapper adaptation."""
-    STARTUP = "startup"           # <100 employees, simple configurations
-    SMB = "small_medium"          # 100-1000 employees, moderate complexity
-    ENTERPRISE = "enterprise"     # 1000-10000 employees, complex environments
-    GLOBAL = "global"             # >10000 employees, multi-region complexity
+
+    STARTUP = "startup"  # <100 employees, simple configurations
+    SMB = "small_medium"  # 100-1000 employees, moderate complexity
+    ENTERPRISE = "enterprise"  # 1000-10000 employees, complex environments
+    GLOBAL = "global"  # >10000 employees, multi-region complexity
 
 
 class ComplianceFramework(Enum):
     """Compliance frameworks supported by enterprise wrappers."""
+
     SOC2 = "soc2"
     PCI_DSS = "pci_dss"
     HIPAA = "hipaa"
@@ -55,15 +63,17 @@ class ComplianceFramework(Enum):
 
 class IntegrationPattern(Enum):
     """Integration patterns for legacy notebook consolidation."""
-    DIRECT_MIGRATION = "direct_migration"         # Direct 1:1 notebook → module
-    BUSINESS_EXTRACTION = "business_extraction"   # Extract business logic only
-    WRAPPER_ADAPTATION = "wrapper_adaptation"     # Wrap existing logic
-    HYBRID_CONSOLIDATION = "hybrid_consolidation" # Mix multiple notebooks
+
+    DIRECT_MIGRATION = "direct_migration"  # Direct 1:1 notebook → module
+    BUSINESS_EXTRACTION = "business_extraction"  # Extract business logic only
+    WRAPPER_ADAPTATION = "wrapper_adaptation"  # Wrap existing logic
+    HYBRID_CONSOLIDATION = "hybrid_consolidation"  # Mix multiple notebooks
 
 
 @dataclass
 class EnterpriseConfiguration:
     """Enterprise-specific configuration for wrapper adaptation."""
+
     organization_name: str
     enterprise_size: EnterpriseSize
     compliance_frameworks: List[ComplianceFramework]
@@ -74,21 +84,22 @@ class EnterpriseConfiguration:
     naming_conventions: Dict[str, str]  # resource_type -> naming_pattern
     business_hours: Dict[str, str]  # timezone and hours configuration
     risk_tolerance: str  # low, medium, high
-    
+
     # FAANG naming enforcement
     faang_naming_enabled: bool = True
     traceability_required: bool = True
     executive_reporting: bool = True
-    
+
     # Legacy integration settings
     legacy_notebook_path: Optional[str] = None
     migration_batch_size: int = 5
     validation_threshold: float = 99.5  # MCP validation accuracy
 
 
-@dataclass 
+@dataclass
 class WrapperResult:
     """Standardized result format for enterprise wrapper operations."""
+
     operation_name: str
     execution_status: str  # success, warning, error, skipped
     business_impact: Dict[str, Any]
@@ -104,74 +115,62 @@ class WrapperResult:
 class EnterpriseWrapper(ABC):
     """
     Abstract base class for enterprise-specific CloudOps automation wrappers.
-    
+
     Provides standardized interface for adapting CloudOps-Automation patterns
     to different enterprise environments while maintaining FAANG naming and
     traceability requirements.
     """
-    
+
     def __init__(self, config: EnterpriseConfiguration):
         """Initialize enterprise wrapper with configuration."""
         self.config = config
         self.execution_history: List[WrapperResult] = []
         self.compliance_validator = ComplianceValidator(config.compliance_frameworks)
-        
+
     @abstractmethod
-    def execute_wrapper_operation(
-        self, 
-        operation_params: Dict[str, Any],
-        dry_run: bool = True
-    ) -> WrapperResult:
+    def execute_wrapper_operation(self, operation_params: Dict[str, Any], dry_run: bool = True) -> WrapperResult:
         """Execute enterprise-wrapped operation with standardized result."""
         pass
-    
+
     def validate_enterprise_compliance(self, operation_result: WrapperResult) -> bool:
         """Validate operation result against enterprise compliance requirements."""
         return self.compliance_validator.validate_result(operation_result)
-    
-    def generate_faang_naming(
-        self, 
-        resource_type: str, 
-        business_context: str
-    ) -> str:
+
+    def generate_faang_naming(self, resource_type: str, business_context: str) -> str:
         """
         Generate FAANG-compliant naming with traceability.
-        
+
         Pattern: {organization}_{resource_type}_{business_context}_{timestamp}
         Example: acme_ebs_cost_optimizer_20241201
         """
         if not self.config.faang_naming_enabled:
             return f"{resource_type}_{business_context}"
-            
+
         timestamp = datetime.now().strftime("%Y%m%d")
-        org_prefix = self.config.organization_name.lower().replace(' ', '_')
-        
+        org_prefix = self.config.organization_name.lower().replace(" ", "_")
+
         faang_name = f"{org_prefix}_{resource_type}_{business_context}_{timestamp}"
-        
+
         # Validate against enterprise naming conventions
         if resource_type in self.config.naming_conventions:
             pattern = self.config.naming_conventions[resource_type]
             if not self._validate_naming_pattern(faang_name, pattern):
                 print_warning(f"Generated name '{faang_name}' doesn't match pattern '{pattern}'")
-                
+
         return faang_name
-    
+
     def _validate_naming_pattern(self, name: str, pattern: str) -> bool:
         """Validate generated name against enterprise pattern."""
         # Simple pattern validation - can be enhanced with regex
-        required_components = pattern.split('_')
-        name_components = name.split('_')
-        
+        required_components = pattern.split("_")
+        name_components = name.split("_")
+
         return len(name_components) >= len(required_components)
-    
-    def create_traceability_record(
-        self, 
-        operation: str, 
-        source_notebook: Optional[str] = None
-    ) -> str:
+
+    def create_traceability_record(self, operation: str, source_notebook: Optional[str] = None) -> str:
         """Create traceability record for enterprise audit requirements."""
         traceability_id = f"{self.config.organization_name}_{operation}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-        
+
         if self.config.traceability_required:
             traceability_record = {
                 "id": traceability_id,
@@ -180,68 +179,60 @@ class EnterpriseWrapper(ABC):
                 "enterprise": self.config.organization_name,
                 "timestamp": datetime.now().isoformat(),
                 "compliance_frameworks": [f.value for f in self.config.compliance_frameworks],
-                "executor": "CloudOps-Automation-Enterprise-Wrapper"
+                "executor": "CloudOps-Automation-Enterprise-Wrapper",
             }
-            
+
             # Store traceability record (implementation depends on enterprise requirements)
             self._store_traceability_record(traceability_record)
-        
+
         return traceability_id
-    
+
     def _store_traceability_record(self, record: Dict[str, Any]) -> None:
         """Store traceability record according to enterprise requirements."""
         # Default implementation - enterprises can override
         artifacts_dir = "./tmp/enterprise_traceability"
         os.makedirs(artifacts_dir, exist_ok=True)
-        
+
         record_path = f"{artifacts_dir}/{record['id']}.json"
-        with open(record_path, 'w') as f:
+        with open(record_path, "w") as f:
             json.dump(record, f, indent=2)
 
 
 class CostOptimizationWrapper(EnterpriseWrapper):
     """
     Enterprise wrapper for cost optimization operations.
-    
+
     Consolidates 18 cost optimization notebooks with enterprise-specific
     adaptations and FAANG naming conventions.
     """
-    
+
     def __init__(self, config: EnterpriseConfiguration):
         """Initialize cost optimization wrapper."""
         super().__init__(config)
         self.supported_operations = [
             "ebs_volume_optimization",
-            "nat_gateway_consolidation", 
+            "nat_gateway_consolidation",
             "elastic_ip_cleanup",
             "ec2_rightsizing",
-            "reserved_instance_planning"
+            "reserved_instance_planning",
         ]
-    
-    def execute_wrapper_operation(
-        self, 
-        operation_params: Dict[str, Any],
-        dry_run: bool = True
-    ) -> WrapperResult:
+
+    def execute_wrapper_operation(self, operation_params: Dict[str, Any], dry_run: bool = True) -> WrapperResult:
         """
         Execute cost optimization with enterprise integration.
-        
+
         Supports operations: ebs_optimization, nat_gateway_cleanup, elastic_ip_management
         """
         operation_type = operation_params.get("operation_type")
-        
+
         if operation_type not in self.supported_operations:
             return self._create_error_result(
-                operation_type or "unknown",
-                f"Unsupported operation. Supported: {', '.join(self.supported_operations)}"
+                operation_type or "unknown", f"Unsupported operation. Supported: {', '.join(self.supported_operations)}"
             )
-        
+
         # Create traceability record
-        traceability_id = self.create_traceability_record(
-            operation_type, 
-            operation_params.get("source_notebook")
-        )
-        
+        traceability_id = self.create_traceability_record(operation_type, operation_params.get("source_notebook"))
+
         try:
             # Execute operation based on type
             if operation_type == "ebs_volume_optimization":
@@ -252,34 +243,30 @@ class CostOptimizationWrapper(EnterpriseWrapper):
                 result = self._execute_elastic_ip_cleanup(operation_params, dry_run)
             else:
                 result = self._execute_generic_cost_optimization(operation_params, dry_run)
-            
+
             # Add traceability and compliance validation
             result.traceability_id = traceability_id
             result.compliance_status = self._validate_compliance_for_result(result)
-            
+
             # Store execution history
             self.execution_history.append(result)
-            
+
             return result
-            
+
         except Exception as e:
             return self._create_error_result(operation_type, str(e), traceability_id)
-    
-    def _execute_ebs_optimization(
-        self, 
-        params: Dict[str, Any], 
-        dry_run: bool
-    ) -> WrapperResult:
+
+    def _execute_ebs_optimization(self, params: Dict[str, Any], dry_run: bool) -> WrapperResult:
         """Execute EBS volume optimization with enterprise patterns."""
-        
+
         print_header("EBS Volume Cost Optimization", "Enterprise Wrapper latest version")
-        
+
         # Enterprise-specific profile resolution
         aws_profile = self._resolve_enterprise_profile("cost_optimization")
-        
+
         # Generate FAANG naming for operation
         operation_name = self.generate_faang_naming("ebs", "cost_optimizer")
-        
+
         # Execute real EBS analysis via runbooks CLI
         try:
             from ..finops.ebs_cost_optimizer import EBSCostOptimizer
@@ -308,8 +295,8 @@ class CostOptimizationWrapper(EnterpriseWrapper):
                 progress.update(task, advance=10, description="Generating recommendations...")
 
                 # Calculate actual savings from results
-                total_savings = sum(float(r.get('annual_savings', 0)) for r in optimization_results)
-                total_volumes = sum(int(r.get('volumes_analyzed', 0)) for r in optimization_results)
+                total_savings = sum(float(r.get("annual_savings", 0)) for r in optimization_results)
+                total_volumes = sum(int(r.get("volumes_analyzed", 0)) for r in optimization_results)
 
         except Exception as e:
             console.print(f"[red]❌ EBS analysis failed: {e}[/red]")
@@ -322,36 +309,38 @@ class CostOptimizationWrapper(EnterpriseWrapper):
             "annual_savings_usd": estimated_savings,
             "cost_reduction_percentage": (estimated_savings / max(params.get("current_spend", 1), 1)) * 100,
             "volumes_analyzed": total_volumes,
-            "optimization_candidates": len([r for r in optimization_results if r.get('optimization_opportunities', 0) > 0]),
-            "roi_percentage": (estimated_savings / max(params.get("implementation_cost", 1000), 1000)) * 100
+            "optimization_candidates": len(
+                [r for r in optimization_results if r.get("optimization_opportunities", 0) > 0]
+            ),
+            "roi_percentage": (estimated_savings / max(params.get("implementation_cost", 1000), 1000)) * 100,
         }
-        
+
         # Technical details
         technical_details = {
             "aws_profile_used": aws_profile,
             "regions_analyzed": ["us-east-1", "us-west-2", "eu-west-1"],
             "analysis_method": "GP2 to GP3 cost comparison with performance analysis",
-            "dry_run_executed": dry_run
+            "dry_run_executed": dry_run,
         }
-        
+
         # Recommendations
         recommendations = [
             f"Migrate 89 GP2 volumes to GP3 for ${estimated_savings:,} annual savings",
             "Schedule migration during maintenance windows to minimize impact",
             "Monitor performance metrics post-migration for 30 days",
-            "Implement automated GP3 selection for new volume creation"
+            "Implement automated GP3 selection for new volume creation",
         ]
-        
+
         # Next steps
         next_steps = [
             "Review volume list with infrastructure team",
             "Schedule pilot migration for 10 volumes",
             "Create migration runbook and rollback procedures",
-            "Execute full migration plan with approval"
+            "Execute full migration plan with approval",
         ]
-        
+
         print_success(f"EBS Optimization Analysis Complete: ${estimated_savings:,} potential savings")
-        
+
         return WrapperResult(
             operation_name=operation_name,
             execution_status="success",
@@ -362,51 +351,47 @@ class CostOptimizationWrapper(EnterpriseWrapper):
             next_steps=next_steps,
             evidence_artifacts=[f"./tmp/{operation_name}_analysis.json"],
             execution_timestamp=datetime.now().isoformat(),
-            traceability_id=""  # Will be set by caller
+            traceability_id="",  # Will be set by caller
         )
-    
-    def _execute_nat_gateway_optimization(
-        self, 
-        params: Dict[str, Any], 
-        dry_run: bool
-    ) -> WrapperResult:
+
+    def _execute_nat_gateway_optimization(self, params: Dict[str, Any], dry_run: bool) -> WrapperResult:
         """Execute NAT Gateway consolidation with enterprise patterns."""
-        
+
         print_header("NAT Gateway Cost Optimization", "Enterprise Wrapper latest version")
-        
+
         aws_profile = self._resolve_enterprise_profile("network_optimization")
         operation_name = self.generate_faang_naming("nat_gateway", "consolidation_engine")
-        
+
         # Real NAT Gateway analysis implementation
         estimated_savings = params.get("projected_savings", 240000)  # $240K example
-        
+
         business_impact = {
             "annual_savings_usd": estimated_savings,
             "monthly_cost_reduction": estimated_savings // 12,
             "nat_gateways_analyzed": 45,
             "consolidation_opportunities": 18,
-            "network_efficiency_gain": "35%"
+            "network_efficiency_gain": "35%",
         }
-        
+
         technical_details = {
             "aws_profile_used": aws_profile,
             "cross_region_analysis": True,
             "traffic_pattern_analysis": "30-day average utilization",
-            "consolidation_strategy": "Multi-AZ optimization with redundancy preservation"
+            "consolidation_strategy": "Multi-AZ optimization with redundancy preservation",
         }
-        
+
         recommendations = [
             f"Consolidate 18 underutilized NAT Gateways for ${estimated_savings:,} annual savings",
-            "Implement cross-AZ traffic routing optimization", 
+            "Implement cross-AZ traffic routing optimization",
             "Establish NAT Gateway utilization monitoring and alerting",
-            "Create automated rightsizing policies for future deployments"
+            "Create automated rightsizing policies for future deployments",
         ]
-        
+
         print_success(f"NAT Gateway Optimization Complete: ${estimated_savings:,} potential savings")
-        
+
         return WrapperResult(
             operation_name=operation_name,
-            execution_status="success", 
+            execution_status="success",
             business_impact=business_impact,
             technical_details=technical_details,
             compliance_status={},
@@ -414,71 +399,63 @@ class CostOptimizationWrapper(EnterpriseWrapper):
             next_steps=["Review consolidation plan", "Execute pilot consolidation", "Monitor network performance"],
             evidence_artifacts=[f"./tmp/{operation_name}_analysis.json"],
             execution_timestamp=datetime.now().isoformat(),
-            traceability_id=""
+            traceability_id="",
         )
-    
-    def _execute_elastic_ip_cleanup(
-        self, 
-        params: Dict[str, Any], 
-        dry_run: bool
-    ) -> WrapperResult:
+
+    def _execute_elastic_ip_cleanup(self, params: Dict[str, Any], dry_run: bool) -> WrapperResult:
         """Execute Elastic IP cleanup with enterprise patterns."""
-        
+
         print_header("Elastic IP Resource Optimization", "Enterprise Wrapper latest version")
-        
-        aws_profile = self._resolve_enterprise_profile("resource_cleanup")  
+
+        aws_profile = self._resolve_enterprise_profile("resource_cleanup")
         operation_name = self.generate_faang_naming("elastic_ip", "efficiency_analyzer")
-        
+
         # Real Elastic IP analysis implementation
         estimated_savings = params.get("projected_savings", 180000)  # $180K example
-        
+
         business_impact = {
             "annual_savings_usd": estimated_savings,
             "monthly_ip_cost_reduction": estimated_savings // 12,
             "unattached_ips_found": 125,
             "optimization_percentage": "78%",
-            "cost_per_ip_monthly": 3.60  # Current AWS pricing
+            "cost_per_ip_monthly": 3.60,  # Current AWS pricing
         }
-        
+
         technical_details = {
             "aws_profile_used": aws_profile,
             "regions_scanned": ["us-east-1", "us-west-2", "eu-central-1", "ap-southeast-1"],
             "analysis_criteria": "Unattached for >7 days, no recent association history",
-            "safety_validation": "Business hours check, tag-based protection"
+            "safety_validation": "Business hours check, tag-based protection",
         }
-        
+
         recommendations = [
             f"Release 125 unattached Elastic IPs for ${estimated_savings:,} annual savings",
             "Implement automated IP lifecycle management policies",
             "Create IP usage monitoring and alerting",
-            "Establish monthly IP optimization reviews"
+            "Establish monthly IP optimization reviews",
         ]
-        
+
         print_success(f"Elastic IP Analysis Complete: ${estimated_savings:,} potential savings")
-        
+
         return WrapperResult(
             operation_name=operation_name,
             execution_status="success",
-            business_impact=business_impact, 
+            business_impact=business_impact,
             technical_details=technical_details,
             compliance_status={},
             recommendations=recommendations,
             next_steps=["Validate IP release list", "Execute cleanup in batches", "Monitor for impacts"],
             evidence_artifacts=[f"./tmp/{operation_name}_analysis.json"],
             execution_timestamp=datetime.now().isoformat(),
-            traceability_id=""
+            traceability_id="",
         )
-    
-    def _execute_generic_cost_optimization(
-        self, 
-        params: Dict[str, Any], 
-        dry_run: bool
-    ) -> WrapperResult:
+
+    def _execute_generic_cost_optimization(self, params: Dict[str, Any], dry_run: bool) -> WrapperResult:
         """Execute generic cost optimization for other operations."""
-        
+
         operation_type = params.get("operation_type", "generic_optimization")
         operation_name = self.generate_faang_naming("cost", operation_type)
-        
+
         return WrapperResult(
             operation_name=operation_name,
             execution_status="success",
@@ -489,26 +466,26 @@ class CostOptimizationWrapper(EnterpriseWrapper):
             next_steps=["Implement optimization plan"],
             evidence_artifacts=[],
             execution_timestamp=datetime.now().isoformat(),
-            traceability_id=""
+            traceability_id="",
         )
-    
+
     def _resolve_enterprise_profile(self, operation_category: str) -> str:
         """Resolve AWS profile based on enterprise configuration and operation."""
         # Default profile mapping
         profile_mapping = {
             "cost_optimization": "billing",
-            "network_optimization": "operational", 
+            "network_optimization": "operational",
             "resource_cleanup": "operational",
-            "security_analysis": "management"
+            "security_analysis": "management",
         }
-        
+
         operation_type = profile_mapping.get(operation_category, "operational")
         return self.config.aws_profiles.get(operation_type, "default")
-    
+
     def _validate_compliance_for_result(self, result: WrapperResult) -> Dict[ComplianceFramework, bool]:
         """Validate operation result against compliance frameworks."""
         compliance_status = {}
-        
+
         for framework in self.config.compliance_frameworks:
             # Simplified compliance validation
             if framework == ComplianceFramework.SOC2:
@@ -517,15 +494,10 @@ class CostOptimizationWrapper(EnterpriseWrapper):
                 compliance_status[framework] = "cost_optimization" in result.operation_name
             else:
                 compliance_status[framework] = True  # Default pass
-        
+
         return compliance_status
-    
-    def _create_error_result(
-        self, 
-        operation: str, 
-        error_message: str,
-        traceability_id: str = ""
-    ) -> WrapperResult:
+
+    def _create_error_result(self, operation: str, error_message: str, traceability_id: str = "") -> WrapperResult:
         """Create standardized error result."""
         return WrapperResult(
             operation_name=f"error_{operation}",
@@ -537,55 +509,45 @@ class CostOptimizationWrapper(EnterpriseWrapper):
             next_steps=["Debug and retry operation"],
             evidence_artifacts=[],
             execution_timestamp=datetime.now().isoformat(),
-            traceability_id=traceability_id
+            traceability_id=traceability_id,
         )
 
 
 class SecurityComplianceWrapper(EnterpriseWrapper):
     """
     Enterprise wrapper for security and compliance operations.
-    
+
     Consolidates 15 security notebooks with enterprise compliance integration.
     """
-    
+
     def __init__(self, config: EnterpriseConfiguration):
         """Initialize security compliance wrapper."""
         super().__init__(config)
         self.supported_operations = [
             "s3_encryption_automation",
-            "iam_security_baseline", 
+            "iam_security_baseline",
             "access_key_rotation",
             "compliance_assessment",
-            "governance_enforcement"
+            "governance_enforcement",
         ]
-    
-    def execute_wrapper_operation(
-        self, 
-        operation_params: Dict[str, Any],
-        dry_run: bool = True
-    ) -> WrapperResult:
+
+    def execute_wrapper_operation(self, operation_params: Dict[str, Any], dry_run: bool = True) -> WrapperResult:
         """Execute security compliance operation with enterprise patterns."""
-        
+
         operation_type = operation_params.get("operation_type")
-        
+
         if operation_type not in self.supported_operations:
             return self._create_error_result(
                 operation_type or "unknown",
-                f"Unsupported security operation. Supported: {', '.join(self.supported_operations)}"
+                f"Unsupported security operation. Supported: {', '.join(self.supported_operations)}",
             )
-        
+
         # Security operations require additional validation
         if not self._validate_security_permissions():
-            return self._create_error_result(
-                operation_type,
-                "Insufficient security permissions for operation"
-            )
-        
-        traceability_id = self.create_traceability_record(
-            operation_type,
-            operation_params.get("source_notebook")
-        )
-        
+            return self._create_error_result(operation_type, "Insufficient security permissions for operation")
+
+        traceability_id = self.create_traceability_record(operation_type, operation_params.get("source_notebook"))
+
         try:
             if operation_type == "s3_encryption_automation":
                 result = self._execute_s3_encryption_automation(operation_params, dry_run)
@@ -593,57 +555,53 @@ class SecurityComplianceWrapper(EnterpriseWrapper):
                 result = self._execute_iam_security_baseline(operation_params, dry_run)
             else:
                 result = self._execute_generic_security_operation(operation_params, dry_run)
-            
+
             result.traceability_id = traceability_id
             result.compliance_status = self._validate_security_compliance(result)
-            
+
             self.execution_history.append(result)
             return result
-            
+
         except Exception as e:
             return self._create_error_result(operation_type, str(e), traceability_id)
-    
+
     def _validate_security_permissions(self) -> bool:
         """Validate that current credentials have required security permissions."""
         # Simplified validation - real implementation would check IAM permissions
         return True
-    
-    def _execute_s3_encryption_automation(
-        self, 
-        params: Dict[str, Any], 
-        dry_run: bool
-    ) -> WrapperResult:
+
+    def _execute_s3_encryption_automation(self, params: Dict[str, Any], dry_run: bool) -> WrapperResult:
         """Execute S3 encryption automation with compliance validation."""
-        
+
         print_header("S3 Bucket Encryption Automation", "Security Wrapper latest version")
-        
+
         aws_profile = self._resolve_enterprise_profile("security_analysis")
         operation_name = self.generate_faang_naming("s3_security", "encryption_automation")
-        
+
         # Real S3 encryption analysis implementation
         business_impact = {
             "buckets_analyzed": 245,
             "unencrypted_buckets": 23,
             "encryption_compliance_improvement": "94%",
-            "risk_mitigation_value": "High - Data protection compliance"
+            "risk_mitigation_value": "High - Data protection compliance",
         }
-        
+
         technical_details = {
             "aws_profile_used": aws_profile,
             "encryption_method": "AWS KMS with customer managed keys",
             "compliance_frameworks_validated": [f.value for f in self.config.compliance_frameworks],
-            "bucket_policy_enforcement": "Deny unencrypted uploads"
+            "bucket_policy_enforcement": "Deny unencrypted uploads",
         }
-        
+
         recommendations = [
             "Enable default encryption on 23 unencrypted S3 buckets",
             "Implement bucket policy enforcement for encryption requirements",
             "Create automated compliance monitoring for new buckets",
-            "Establish quarterly encryption compliance reviews"
+            "Establish quarterly encryption compliance reviews",
         ]
-        
+
         print_success("S3 Encryption Analysis Complete: 23 buckets require encryption")
-        
+
         return WrapperResult(
             operation_name=operation_name,
             execution_status="success",
@@ -654,45 +612,41 @@ class SecurityComplianceWrapper(EnterpriseWrapper):
             next_steps=["Review encryption requirements", "Implement bucket encryption", "Validate compliance"],
             evidence_artifacts=[f"./tmp/{operation_name}_compliance_report.json"],
             execution_timestamp=datetime.now().isoformat(),
-            traceability_id=""
+            traceability_id="",
         )
-    
-    def _execute_iam_security_baseline(
-        self, 
-        params: Dict[str, Any], 
-        dry_run: bool
-    ) -> WrapperResult:
+
+    def _execute_iam_security_baseline(self, params: Dict[str, Any], dry_run: bool) -> WrapperResult:
         """Execute IAM security baseline assessment."""
-        
+
         print_header("IAM Security Baseline Assessment", "Security Wrapper latest version")
-        
+
         aws_profile = self._resolve_enterprise_profile("security_analysis")
         operation_name = self.generate_faang_naming("iam_security", "baseline_assessment")
-        
+
         business_impact = {
             "users_analyzed": 156,
             "excessive_permissions_found": 34,
             "access_key_rotation_required": 12,
             "security_posture_improvement": "67%",
-            "compliance_risk_reduction": "High"
+            "compliance_risk_reduction": "High",
         }
-        
+
         technical_details = {
             "aws_profile_used": aws_profile,
             "least_privilege_analysis": "Policy analysis with unused permission identification",
             "access_key_age_threshold": "90 days",
-            "mfa_enforcement_analysis": "Multi-factor authentication requirement validation"
+            "mfa_enforcement_analysis": "Multi-factor authentication requirement validation",
         }
-        
+
         recommendations = [
             "Remediate excessive permissions for 34 IAM users",
             "Implement access key rotation for 12 users with old keys",
             "Enforce MFA requirements for privileged accounts",
-            "Establish automated IAM security monitoring"
+            "Establish automated IAM security monitoring",
         ]
-        
+
         print_success("IAM Security Baseline Complete: 46 security improvements identified")
-        
+
         return WrapperResult(
             operation_name=operation_name,
             execution_status="success",
@@ -703,19 +657,15 @@ class SecurityComplianceWrapper(EnterpriseWrapper):
             next_steps=["Prioritize security remediation", "Implement access controls", "Monitor compliance"],
             evidence_artifacts=[f"./tmp/{operation_name}_security_report.json"],
             execution_timestamp=datetime.now().isoformat(),
-            traceability_id=""
+            traceability_id="",
         )
-    
-    def _execute_generic_security_operation(
-        self, 
-        params: Dict[str, Any], 
-        dry_run: bool
-    ) -> WrapperResult:
+
+    def _execute_generic_security_operation(self, params: Dict[str, Any], dry_run: bool) -> WrapperResult:
         """Execute generic security operation."""
-        
+
         operation_type = params.get("operation_type", "generic_security")
         operation_name = self.generate_faang_naming("security", operation_type)
-        
+
         return WrapperResult(
             operation_name=operation_name,
             execution_status="success",
@@ -726,32 +676,27 @@ class SecurityComplianceWrapper(EnterpriseWrapper):
             next_steps=["Implement security improvements"],
             evidence_artifacts=[],
             execution_timestamp=datetime.now().isoformat(),
-            traceability_id=""
+            traceability_id="",
         )
-    
+
     def _validate_security_compliance(self, result: WrapperResult) -> Dict[ComplianceFramework, bool]:
         """Validate security operation against compliance frameworks."""
         compliance_status = {}
-        
+
         for framework in self.config.compliance_frameworks:
             if framework in [ComplianceFramework.SOC2, ComplianceFramework.PCI_DSS, ComplianceFramework.HIPAA]:
                 # Security operations generally support these frameworks
                 compliance_status[framework] = result.execution_status == "success"
             else:
                 compliance_status[framework] = True
-        
+
         return compliance_status
-    
+
     def _resolve_enterprise_profile(self, operation_category: str) -> str:
         """Resolve AWS profile for security operations."""
         return self.config.aws_profiles.get("management", "default")
-    
-    def _create_error_result(
-        self, 
-        operation: str, 
-        error_message: str,
-        traceability_id: str = ""
-    ) -> WrapperResult:
+
+    def _create_error_result(self, operation: str, error_message: str, traceability_id: str = "") -> WrapperResult:
         """Create standardized security error result."""
         return WrapperResult(
             operation_name=f"security_error_{operation}",
@@ -763,58 +708,49 @@ class SecurityComplianceWrapper(EnterpriseWrapper):
             next_steps=["Review security configuration", "Retry operation"],
             evidence_artifacts=[],
             execution_timestamp=datetime.now().isoformat(),
-            traceability_id=traceability_id
+            traceability_id=traceability_id,
         )
 
 
 class ComplianceValidator:
     """Validate operations against enterprise compliance requirements."""
-    
+
     def __init__(self, frameworks: List[ComplianceFramework]):
         """Initialize compliance validator with required frameworks."""
         self.required_frameworks = frameworks
-        
+
     def validate_result(self, result: WrapperResult) -> bool:
         """Validate operation result against all required compliance frameworks."""
         if not self.required_frameworks:
             return True  # No compliance requirements
-            
+
         # All frameworks must pass for overall compliance
-        return all(
-            result.compliance_status.get(framework, False) 
-            for framework in self.required_frameworks
-        )
+        return all(result.compliance_status.get(framework, False) for framework in self.required_frameworks)
 
 
-def create_enterprise_wrapper(
-    wrapper_type: str, 
-    config: EnterpriseConfiguration
-) -> EnterpriseWrapper:
+def create_enterprise_wrapper(wrapper_type: str, config: EnterpriseConfiguration) -> EnterpriseWrapper:
     """
     Factory function to create appropriate enterprise wrapper.
-    
+
     Args:
         wrapper_type: Type of wrapper (cost_optimization, security_compliance)
         config: Enterprise configuration
-        
+
     Returns:
         Configured enterprise wrapper instance
     """
-    wrapper_registry = {
-        "cost_optimization": CostOptimizationWrapper,
-        "security_compliance": SecurityComplianceWrapper
-    }
-    
+    wrapper_registry = {"cost_optimization": CostOptimizationWrapper, "security_compliance": SecurityComplianceWrapper}
+
     if wrapper_type not in wrapper_registry:
         raise ValueError(f"Unknown wrapper type: {wrapper_type}. Supported: {list(wrapper_registry.keys())}")
-    
+
     wrapper_class = wrapper_registry[wrapper_type]
     return wrapper_class(config)
 
 
 def main():
     """Demo enterprise wrapper functionality."""
-    
+
     # Example enterprise configuration
     demo_config = EnterpriseConfiguration(
         organization_name="ACME Corporation",
@@ -822,33 +758,35 @@ def main():
         compliance_frameworks=[ComplianceFramework.SOC2, ComplianceFramework.AWS_WELL_ARCHITECTED],
         aws_profiles={
             "billing": "acme-billing-readonly",
-            "operational": "acme-ops-readonly", 
-            "management": "acme-mgmt-readonly"
+            "operational": "acme-ops-readonly",
+            "management": "acme-mgmt-readonly",
         },
         cost_allocation_tags=["Department", "Project", "Environment"],
         approval_workflows={"cost_optimization": ["manager", "finance"]},
         notification_channels={"slack": "#cloudops-alerts"},
         naming_conventions={"ebs": "acme_ebs_{purpose}_{date}"},
         business_hours={"timezone": "US/Eastern", "hours": "9-17"},
-        risk_tolerance="medium"
+        risk_tolerance="medium",
     )
-    
+
     print_header("Enterprise Wrapper Demo", "latest version")
-    
+
     # Demo cost optimization wrapper
     cost_wrapper = create_enterprise_wrapper("cost_optimization", demo_config)
-    
-    result = cost_wrapper.execute_wrapper_operation({
-        "operation_type": "ebs_volume_optimization",
-        "projected_savings": 200000,
-        "source_notebook": "AWS_Change_EBS_Volume_To_GP3_Type.ipynb"
-    })
-    
+
+    result = cost_wrapper.execute_wrapper_operation(
+        {
+            "operation_type": "ebs_volume_optimization",
+            "projected_savings": 200000,
+            "source_notebook": "AWS_Change_EBS_Volume_To_GP3_Type.ipynb",
+        }
+    )
+
     print_success(f"Demo completed: {result.operation_name}")
     print_success(f"Business Impact: ${result.business_impact.get('annual_savings_usd', 0):,} potential savings")
-    
+
     return result
 
 
 if __name__ == "__main__":
-    main()
+    main()