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

runbooks/operate/vpc_operations.py

@@ -73,8 +73,14 @@ from botocore.exceptions import ClientError
 from loguru import logger
 
 from runbooks.common.rich_utils import (
-    console, create_table, print_warning, print_success, print_error, 
-    print_info, print_header, create_panel
+    console,
+    create_table,
+    print_warning,
+    print_success,
+    print_error,
+    print_info,
+    print_header,
+    create_panel,
 )
 from runbooks.operate.base import BaseOperation, OperationContext, OperationResult, OperationStatus
 
@@ -84,13 +90,13 @@ from runbooks.inventory.vpc_analyzer import VPCAnalyzer, VPCDiscoveryResult, AWS
 
 class RichConsoleWrapper:
     """Wrapper to provide missing methods for VPC operations."""
-    
+
     def __init__(self, console_instance):
         self.console = console_instance
-    
+
     def print(self, *args, **kwargs):
         return self.console.print(*args, **kwargs)
-    
+
     def print_panel(self, content, subtitle=None, title="Panel", style=None):
         """Print a panel with content."""
         panel_content = content
@@ -98,23 +104,23 @@ class RichConsoleWrapper:
             panel_content = f"{content}\n\n{subtitle}"
         panel = create_panel(panel_content, title=title)
         self.console.print(panel)
-    
+
     def print_table(self, table):
         """Print a table."""
         self.console.print(table)
-    
+
     def print_success(self, message):
         return print_success(message)
-    
+
     def print_error(self, message):
         return print_error(message)
-    
+
     def print_info(self, message):
         return print_info(message)
-    
+
     def print_warning(self, message):
         return print_warning(message)
-    
+
     def print_header(self, title, subtitle=None):
         """Print header with Rich CLI standards - convert subtitle to version parameter."""
         if subtitle:
@@ -167,6 +173,7 @@ class NATGatewayConfiguration:
         if "MonthlyCostEstimate" not in self.tags:
             try:
                 from ..common.aws_pricing import get_service_monthly_cost
+
                 monthly_cost = get_service_monthly_cost("nat_gateway", "us-east-1")  # Default region
                 self.tags["MonthlyCostEstimate"] = f"${monthly_cost:.2f}"
             except Exception:
@@ -260,35 +267,32 @@ class VPCOperations(BaseOperation):
         self.rich_console = RichConsoleWrapper(console)
 
         # VPC Module Migration Integration - Discovery capabilities
-        self.vpc_analyzer = VPCAnalyzer(
-            profile=profile,
-            region=region,
-            console=console,
-            dry_run=dry_run
-        )
+        self.vpc_analyzer = VPCAnalyzer(profile=profile, region=region, console=console, dry_run=dry_run)
 
         # Cost tracking using enhanced AWS pricing API with enterprise fallback
         import os
-        os.environ['AWS_PRICING_STRICT_COMPLIANCE'] = os.getenv('AWS_PRICING_STRICT_COMPLIANCE', 'false')
-        
+
+        os.environ["AWS_PRICING_STRICT_COMPLIANCE"] = os.getenv("AWS_PRICING_STRICT_COMPLIANCE", "false")
+
         try:
             from ..common.aws_pricing_api import pricing_api
-            
+
             # Get dynamic pricing with enhanced fallback support
-            current_region = region or os.getenv('AWS_DEFAULT_REGION', 'us-east-1')
-            
+            current_region = region or os.getenv("AWS_DEFAULT_REGION", "us-east-1")
+
             self.nat_gateway_monthly_cost = pricing_api.get_nat_gateway_monthly_cost(current_region)
             logger.info(f"✅ Dynamic NAT Gateway cost: ${self.nat_gateway_monthly_cost:.2f}/month")
-            
+
             # Elastic IP pricing (using NAT Gateway as proxy for network pricing)
             self.elastic_ip_monthly_cost = self.nat_gateway_monthly_cost * 0.1  # EIP typically 10% of NAT Gateway
             logger.info(f"✅ Dynamic Elastic IP cost: ${self.elastic_ip_monthly_cost:.2f}/month")
-            
+
         except Exception as e:
             logger.warning(f"⚠️ Enhanced pricing fallback: {e}")
             # Use config-based pricing as ultimate fallback
             try:
                 from ..vpc.config import load_config
+
                 vpc_config = load_config()
                 self.nat_gateway_monthly_cost = vpc_config.cost_model.nat_gateway_monthly
                 self.elastic_ip_monthly_cost = vpc_config.cost_model.elastic_ip_idle_monthly
@@ -296,13 +300,17 @@ class VPCOperations(BaseOperation):
                 logger.info(f"✅ Config-based Elastic IP cost: ${self.elastic_ip_monthly_cost:.2f}/month")
             except Exception as config_error:
                 logger.error(f"🚫 All pricing methods failed: {config_error}")
-                raise RuntimeError("Unable to get pricing for VPC analysis. Check AWS credentials and IAM permissions.") from config_error
-        
+                raise RuntimeError(
+                    "Unable to get pricing for VPC analysis. Check AWS credentials and IAM permissions."
+                ) from config_error
+
         # VPC module patterns integration
         self.last_discovery_result = None
         self.last_awso_analysis = None
 
-        logger.info(f"VPC Operations initialized with VPC Analyzer - Profile: {profile}, Region: {region}, Dry-run: {dry_run}")
+        logger.info(
+            f"VPC Operations initialized with VPC Analyzer - Profile: {profile}, Region: {region}, Dry-run: {dry_run}"
+        )
 
     def execute_operation(self, context: OperationContext, operation_type: str, **kwargs) -> List[OperationResult]:
         """
@@ -378,7 +386,7 @@ class VPCOperations(BaseOperation):
                 f"Region: {context.region}\n"
                 f"DNS Hostnames: {vpc_config.enable_dns_hostnames}\n"
                 f"Instance Tenancy: {vpc_config.instance_tenancy}",
-                title="🏗️ VPC Creation"
+                title="🏗️ VPC Creation",
             )
 
             if context.dry_run:
@@ -862,30 +870,28 @@ class VPCOperations(BaseOperation):
     def discover_vpc_topology_comprehensive(self, vpc_ids: Optional[List[str]] = None) -> VPCDiscoveryResult:
         """
         Comprehensive VPC topology discovery using migrated VPC module capabilities.
-        
+
         Integrates networking_wrapper.py discovery patterns with operate module operations.
         Provides complete VPC topology analysis for AWSO-05 cleanup workflows.
-        
+
         Args:
             vpc_ids: Optional list of specific VPC IDs to analyze
-            
+
         Returns:
             VPCDiscoveryResult with complete topology information
         """
         self.rich_console.print_header("VPC Topology Discovery", "Enhanced with VPC Module Integration")
-        
+
         try:
             # Use integrated VPC analyzer for discovery
             discovery_result = self.vpc_analyzer.discover_vpc_topology(vpc_ids)
             self.last_discovery_result = discovery_result
-            
+
             # Display enterprise summary with cost information
-            total_monthly_cost = sum([
-                nat['EstimatedMonthlyCost'] for nat in discovery_result.nat_gateways
-            ]) + sum([
-                ep['EstimatedMonthlyCost'] for ep in discovery_result.vpc_endpoints
-            ])
-            
+            total_monthly_cost = sum([nat["EstimatedMonthlyCost"] for nat in discovery_result.nat_gateways]) + sum(
+                [ep["EstimatedMonthlyCost"] for ep in discovery_result.vpc_endpoints]
+            )
+
             self.rich_console.print_panel(
                 "VPC Discovery Integration Complete",
                 f"Total VPCs: {len(discovery_result.vpcs)}\n"
@@ -894,53 +900,55 @@ class VPCOperations(BaseOperation):
                 f"Network Interfaces: {len(discovery_result.network_interfaces)}\n"
                 f"Estimated Monthly Network Cost: ${total_monthly_cost:.2f}\n"
                 f"Discovery Timestamp: {discovery_result.discovery_timestamp}",
-                title="🔍 VPC Module Integration"
+                title="🔍 VPC Module Integration",
             )
-            
+
             return discovery_result
-            
+
         except Exception as e:
             logger.error(f"VPC topology discovery failed: {e}")
             self.rich_console.print_error(f"❌ VPC discovery failed: {e}")
             raise
 
-    def analyze_awso_dependencies_comprehensive(self, discovery_result: Optional[VPCDiscoveryResult] = None) -> AWSOAnalysis:
+    def analyze_awso_dependencies_comprehensive(
+        self, discovery_result: Optional[VPCDiscoveryResult] = None
+    ) -> AWSOAnalysis:
         """
         AWSO-05 dependency analysis using migrated VPC module capabilities.
-        
+
         Integrates cost_engine.py analysis patterns with AWSO-05 cleanup requirements.
         Provides 12-step dependency validation for safe VPC cleanup operations.
-        
+
         Args:
             discovery_result: Previous discovery result (uses last if None)
-            
+
         Returns:
             AWSOAnalysis with comprehensive dependency mapping
         """
         self.rich_console.print_header("AWSO-05 Dependency Analysis", "12-Step Framework Integration")
-        
+
         try:
             # Use integrated VPC analyzer for AWSO analysis
             awso_analysis = self.vpc_analyzer.analyze_awso_dependencies(discovery_result)
             self.last_awso_analysis = awso_analysis
-            
+
             # Display business-critical warnings
             if awso_analysis.eni_gate_warnings:
                 self.rich_console.print_warning(
                     f"🚨 CRITICAL: {len(awso_analysis.eni_gate_warnings)} ENI gate warnings detected!\n"
                     "VPC cleanup may disrupt active workloads. Review migration requirements."
                 )
-            
+
             if awso_analysis.default_vpcs:
                 self.rich_console.print_info(
                     f"🎯 Default VPCs found: {len(awso_analysis.default_vpcs)}\n"
                     "CIS Benchmark compliance can be improved through cleanup."
                 )
-            
+
             # Display cleanup readiness status
-            cleanup_status = awso_analysis.evidence_bundle.get('CleanupReadiness', 'UNKNOWN')
-            status_style = "green" if cleanup_status == 'READY' else "yellow"
-            
+            cleanup_status = awso_analysis.evidence_bundle.get("CleanupReadiness", "UNKNOWN")
+            status_style = "green" if cleanup_status == "READY" else "yellow"
+
             self.rich_console.print_panel(
                 "AWSO-05 Analysis Complete",
                 f"Default VPCs: {len(awso_analysis.default_vpcs)}\n"
@@ -948,11 +956,11 @@ class VPCOperations(BaseOperation):
                 f"Cleanup Recommendations: {len(awso_analysis.cleanup_recommendations)}\n"
                 f"Cleanup Readiness: {cleanup_status}",
                 title="🎯 AWSO-05 Analysis Results",
-                style=status_style
+                style=status_style,
             )
-            
+
             return awso_analysis
-            
+
         except Exception as e:
             logger.error(f"AWSO-05 analysis failed: {e}")
             self.rich_console.print_error(f"❌ AWSO-05 analysis failed: {e}")
@@ -961,106 +969,111 @@ class VPCOperations(BaseOperation):
     def generate_vpc_evidence_bundle(self, output_dir: str = "./awso_evidence") -> Dict[str, str]:
         """
         Generate comprehensive evidence bundle using migrated VPC module capabilities.
-        
+
         Integrates manager_interface.py reporting patterns with AWSO-05 compliance requirements.
         Creates SHA256-verified evidence bundle for audit trails and compliance.
-        
+
         Args:
             output_dir: Directory to store evidence files
-            
+
         Returns:
             Dict with generated file paths and checksums
         """
         self.rich_console.print_header("Evidence Bundle Generation", "Enterprise Compliance Integration")
-        
+
         try:
             # Use integrated VPC analyzer for evidence generation
             evidence_files = self.vpc_analyzer.generate_cleanup_evidence(output_dir)
-            
+
             if evidence_files:
                 self.rich_console.print_success(
                     f"✅ Evidence bundle generated successfully!\n"
                     f"Files created: {len(evidence_files)}\n"
                     f"Output directory: {output_dir}"
                 )
-                
+
                 # Display evidence summary for manager interface compatibility
                 self.rich_console.print_panel(
                     "Evidence Bundle Summary",
-                    "\n".join([f"• {evidence_type}: {file_path.split('/')[-1]}" 
-                             for evidence_type, file_path in evidence_files.items()]),
-                    title="📋 AWSO-05 Evidence Files"
+                    "\n".join(
+                        [
+                            f"• {evidence_type}: {file_path.split('/')[-1]}"
+                            for evidence_type, file_path in evidence_files.items()
+                        ]
+                    ),
+                    title="📋 AWSO-05 Evidence Files",
                 )
             else:
                 self.rich_console.print_warning("⚠️ No evidence files generated - run discovery and analysis first")
-            
+
             return evidence_files
-            
+
         except Exception as e:
             logger.error(f"Evidence bundle generation failed: {e}")
             self.rich_console.print_error(f"❌ Evidence bundle generation failed: {e}")
             raise
 
-    def execute_integrated_vpc_analysis(self, vpc_ids: Optional[List[str]] = None, 
-                                      generate_evidence: bool = True) -> Dict[str, Any]:
+    def execute_integrated_vpc_analysis(
+        self, vpc_ids: Optional[List[str]] = None, generate_evidence: bool = True
+    ) -> Dict[str, Any]:
         """
         Execute complete integrated VPC analysis workflow using migrated VPC module capabilities.
-        
+
         Combines networking_wrapper.py, cost_engine.py, and manager_interface.py patterns
         into a single comprehensive analysis workflow for enterprise VPC management.
-        
+
         Args:
             vpc_ids: Optional list of specific VPC IDs to analyze
             generate_evidence: Whether to generate evidence bundle
-            
+
         Returns:
             Dict with complete analysis results and evidence files
         """
         self.rich_console.print_header("Integrated VPC Analysis", "Complete VPC Module Integration")
-        
+
         workflow_results = {
-            'discovery_result': None,
-            'awso_analysis': None,
-            'evidence_files': None,
-            'analysis_summary': {}
+            "discovery_result": None,
+            "awso_analysis": None,
+            "evidence_files": None,
+            "analysis_summary": {},
         }
-        
+
         try:
             # Step 1: VPC Topology Discovery
             self.rich_console.print_info("🔍 Step 1: VPC Topology Discovery...")
             discovery_result = self.discover_vpc_topology_comprehensive(vpc_ids)
-            workflow_results['discovery_result'] = discovery_result
-            
+            workflow_results["discovery_result"] = discovery_result
+
             # Step 2: AWSO-05 Dependency Analysis
             self.rich_console.print_info("🎯 Step 2: AWSO-05 Dependency Analysis...")
             awso_analysis = self.analyze_awso_dependencies_comprehensive(discovery_result)
-            workflow_results['awso_analysis'] = awso_analysis
-            
+            workflow_results["awso_analysis"] = awso_analysis
+
             # Step 3: Evidence Bundle Generation (if requested)
             if generate_evidence:
                 self.rich_console.print_info("📋 Step 3: Evidence Bundle Generation...")
                 evidence_files = self.generate_vpc_evidence_bundle()
-                workflow_results['evidence_files'] = evidence_files
-            
+                workflow_results["evidence_files"] = evidence_files
+
             # Step 4: Analysis Summary (manager interface compatibility)
-            total_monthly_cost = sum([
-                nat['EstimatedMonthlyCost'] for nat in discovery_result.nat_gateways
-            ]) + sum([
-                ep['EstimatedMonthlyCost'] for ep in discovery_result.vpc_endpoints
-            ])
-            
-            workflow_results['analysis_summary'] = {
-                'total_resources': discovery_result.total_resources,
-                'estimated_monthly_cost': total_monthly_cost,
-                'default_vpcs_found': len(awso_analysis.default_vpcs),
-                'eni_gate_warnings': len(awso_analysis.eni_gate_warnings),
-                'cleanup_recommendations': len(awso_analysis.cleanup_recommendations),
-                'cleanup_readiness': awso_analysis.evidence_bundle.get('CleanupReadiness', 'UNKNOWN'),
-                'cis_benchmark_compliance': awso_analysis.evidence_bundle.get('ComplianceStatus', {}).get('CISBenchmark', 'UNKNOWN')
+            total_monthly_cost = sum([nat["EstimatedMonthlyCost"] for nat in discovery_result.nat_gateways]) + sum(
+                [ep["EstimatedMonthlyCost"] for ep in discovery_result.vpc_endpoints]
+            )
+
+            workflow_results["analysis_summary"] = {
+                "total_resources": discovery_result.total_resources,
+                "estimated_monthly_cost": total_monthly_cost,
+                "default_vpcs_found": len(awso_analysis.default_vpcs),
+                "eni_gate_warnings": len(awso_analysis.eni_gate_warnings),
+                "cleanup_recommendations": len(awso_analysis.cleanup_recommendations),
+                "cleanup_readiness": awso_analysis.evidence_bundle.get("CleanupReadiness", "UNKNOWN"),
+                "cis_benchmark_compliance": awso_analysis.evidence_bundle.get("ComplianceStatus", {}).get(
+                    "CISBenchmark", "UNKNOWN"
+                ),
             }
-            
+
             # Display comprehensive summary
-            summary = workflow_results['analysis_summary']
+            summary = workflow_results["analysis_summary"]
             self.rich_console.print_panel(
                 "Integrated VPC Analysis Complete",
                 f"Total Resources Discovered: {summary['total_resources']}\n"
@@ -1070,11 +1083,11 @@ class VPCOperations(BaseOperation):
                 f"Cleanup Recommendations: {summary['cleanup_recommendations']}\n"
                 f"Cleanup Readiness: {summary['cleanup_readiness']}\n"
                 f"CIS Benchmark Status: {summary['cis_benchmark_compliance']}",
-                title="🏆 VPC Module Integration Results"
+                title="🏆 VPC Module Integration Results",
             )
-            
+
             return workflow_results
-            
+
         except Exception as e:
             logger.error(f"Integrated VPC analysis failed: {e}")
             self.rich_console.print_error(f"❌ Integrated VPC analysis failed: {e}")
@@ -1392,52 +1405,54 @@ class VPCOperations(BaseOperation):
         except Exception as e:
             logger.warning(f"Could not get all regions, using defaults: {e}")
             return ["us-east-1", "us-west-2", "eu-west-1", "ap-southeast-1"]
-    
+
     def _get_nat_gateway_monthly_cost(self) -> float:
         """
         Get dynamic NAT Gateway monthly cost from AWS Pricing API.
-        
+
         Returns:
             float: Monthly cost for NAT Gateway
         """
         try:
             # Use AWS Pricing API to get real NAT Gateway pricing
-            pricing_client = self.session.client('pricing', region_name='us-east-1')
-            
+            pricing_client = self.session.client("pricing", region_name="us-east-1")
+
             nat_gateway_response = pricing_client.get_products(
-                ServiceCode='AmazonVPC',
+                ServiceCode="AmazonVPC",
                 Filters=[
-                    {'Type': 'TERM_MATCH', 'Field': 'productFamily', 'Value': 'NAT Gateway'},
-                    {'Type': 'TERM_MATCH', 'Field': 'location', 'Value': 'US East (N. Virginia)'}
+                    {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "NAT Gateway"},
+                    {"Type": "TERM_MATCH", "Field": "location", "Value": "US East (N. Virginia)"},
                 ],
-                MaxResults=1
+                MaxResults=1,
             )
-            
-            if nat_gateway_response.get('PriceList'):
+
+            if nat_gateway_response.get("PriceList"):
                 import json
-                price_data = json.loads(nat_gateway_response['PriceList'][0])
-                terms = price_data.get('terms', {}).get('OnDemand', {})
+
+                price_data = json.loads(nat_gateway_response["PriceList"][0])
+                terms = price_data.get("terms", {}).get("OnDemand", {})
                 if terms:
                     term_data = list(terms.values())[0]
-                    price_dims = term_data.get('priceDimensions', {})
+                    price_dims = term_data.get("priceDimensions", {})
                     if price_dims:
                         price_dim = list(price_dims.values())[0]
-                        usd_price = price_dim.get('pricePerUnit', {}).get('USD', '0')
-                        if usd_price == '0' or not usd_price:
+                        usd_price = price_dim.get("pricePerUnit", {}).get("USD", "0")
+                        if usd_price == "0" or not usd_price:
                             raise ValueError("No valid pricing found in AWS response")
                         hourly_rate = float(usd_price)
                         monthly_rate = hourly_rate * 24 * 30  # Convert to monthly
                         return monthly_rate
-            
+
             # Fallback to environment variable
             import os
-            env_nat_cost = os.getenv('NAT_GATEWAY_MONTHLY_COST')
+
+            env_nat_cost = os.getenv("NAT_GATEWAY_MONTHLY_COST")
             if env_nat_cost:
                 return float(env_nat_cost)
-            
+
             # Final fallback: calculated estimate based on AWS pricing
             return 32.4  # Current AWS NAT Gateway monthly rate (calculated, not hardcoded)
-            
+
         except Exception as e:
             self.console.print(f"[yellow]Warning: Could not fetch NAT Gateway pricing: {e}[/yellow]")
             return 32.4  # Calculated estimate
@@ -1450,8 +1465,10 @@ class VPCOperations(BaseOperation):
 from enum import Enum
 from pathlib import Path
 
+
 class BusinessPriority(Enum):
     """Business priority levels for manager decision making"""
+
     CRITICAL = "Critical"
     HIGH = "High"
     MEDIUM = "Medium"
@@ -1460,6 +1477,7 @@ class BusinessPriority(Enum):
 
 class RiskLevel(Enum):
     """Risk assessment levels for business decisions"""
+
     MINIMAL = "Minimal"
     LOW = "Low"
     MEDIUM = "Medium"
@@ -1469,6 +1487,7 @@ class RiskLevel(Enum):
 @dataclass
 class BusinessRecommendation:
     """Business-focused recommendation structure migrated from vpc module"""
+
     title: str
     executive_summary: str
     monthly_savings: float
@@ -1486,6 +1505,7 @@ class BusinessRecommendation:
 @dataclass
 class ManagerDashboardConfig:
     """Configuration for manager dashboard behavior"""
+
     safety_mode: bool = True
     auto_export: bool = True
     executive_summaries_only: bool = False
@@ -1502,17 +1522,17 @@ class ManagerDashboardConfig:
 class EnhancedVPCNetworkingManager(BaseOperation):
     """
     Enhanced VPC Networking Manager - Migrated capabilities from vpc module
-    
-    Integrates networking_wrapper.py, manager_interface.py, and cost_engine.py 
+
+    Integrates networking_wrapper.py, manager_interface.py, and cost_engine.py
     capabilities into operate module following "Do one thing and do it well" principle.
-    
+
     Provides enterprise VPC management with:
     - Manager-friendly business interface
     - Cost optimization with MCP validation
     - Network topology management
     - Safety-first operations with approval workflows
     """
-    
+
     def __init__(self, dry_run: bool = True):
         super().__init__(dry_run=dry_run)
         self.operation_name = "enhanced_vpc_networking"
@@ -1520,55 +1540,64 @@ class EnhancedVPCNetworkingManager(BaseOperation):
         self.analysis_results = {}
         self.business_recommendations = []
         self.export_directory = Path("./tmp/manager_dashboard")
-        
+
         # Enhanced cost model integration using new AWS pricing API with enterprise fallback
         try:
             from ..common.aws_pricing_api import pricing_api
             import os
-            
+
             # Enable fallback mode for operational compatibility
-            os.environ['AWS_PRICING_STRICT_COMPLIANCE'] = os.getenv('AWS_PRICING_STRICT_COMPLIANCE', 'false')
-            
+            os.environ["AWS_PRICING_STRICT_COMPLIANCE"] = os.getenv("AWS_PRICING_STRICT_COMPLIANCE", "false")
+
             # Get dynamic pricing for all VPC services with enhanced fallback
             nat_monthly = pricing_api.get_nat_gateway_monthly_cost(self.region)
-            
+
             # Convert to expected units
             self.nat_gateway_hourly_cost = nat_monthly / (24 * 30)  # Monthly to hourly
             self.nat_gateway_data_processing = self.nat_gateway_hourly_cost  # Same rate for data
-            
+
             # Use proportional pricing for other services
             self.transit_gateway_monthly_cost = nat_monthly * 1.11  # TGW slightly higher than NAT
             self.vpc_endpoint_hourly_cost = self.nat_gateway_hourly_cost * 0.22  # VPC Endpoint lower
-            
-            logger.info(f"✅ Enhanced VPC pricing loaded: NAT=${self.nat_gateway_hourly_cost:.4f}/hr, "
-                       f"TGW=${self.transit_gateway_monthly_cost:.2f}/mo, VPCEndpoint=${self.vpc_endpoint_hourly_cost:.4f}/hr")
-                       
+
+            logger.info(
+                f"✅ Enhanced VPC pricing loaded: NAT=${self.nat_gateway_hourly_cost:.4f}/hr, "
+                f"TGW=${self.transit_gateway_monthly_cost:.2f}/mo, VPCEndpoint=${self.vpc_endpoint_hourly_cost:.4f}/hr"
+            )
+
         except Exception as e:
             logger.warning(f"⚠️ Enhanced pricing API fallback: {e}")
             # Use config-based pricing as final fallback
             try:
                 from ..vpc.config import load_config
+
                 vpc_config = load_config()
-                
+
                 self.nat_gateway_hourly_cost = vpc_config.cost_model.nat_gateway_hourly
                 self.nat_gateway_data_processing = vpc_config.cost_model.nat_gateway_data_processing
                 self.transit_gateway_monthly_cost = vpc_config.cost_model.transit_gateway_monthly
                 self.vpc_endpoint_hourly_cost = vpc_config.cost_model.vpc_endpoint_interface_hourly
-                
-                logger.info(f"✅ Config-based VPC pricing loaded: NAT=${self.nat_gateway_hourly_cost:.4f}/hr, "
-                           f"TGW=${self.transit_gateway_monthly_cost:.2f}/mo, VPCEndpoint=${self.vpc_endpoint_hourly_cost:.4f}/hr")
-                           
+
+                logger.info(
+                    f"✅ Config-based VPC pricing loaded: NAT=${self.nat_gateway_hourly_cost:.4f}/hr, "
+                    f"TGW=${self.transit_gateway_monthly_cost:.2f}/mo, VPCEndpoint=${self.vpc_endpoint_hourly_cost:.4f}/hr"
+                )
+
             except Exception as config_error:
                 logger.error(f"🚫 All pricing methods failed: {config_error}")
-                logger.error("💡 Ensure AWS credentials are configured or set AWS_PRICING_OVERRIDE_* environment variables")
-                raise RuntimeError("Unable to get pricing for VPC analysis. Check AWS credentials and IAM permissions.") from config_error
-        
+                logger.error(
+                    "💡 Ensure AWS credentials are configured or set AWS_PRICING_OVERRIDE_* environment variables"
+                )
+                raise RuntimeError(
+                    "Unable to get pricing for VPC analysis. Check AWS credentials and IAM permissions."
+                ) from config_error
+
     def execute_operation(self, context: OperationContext, operation_type: str, **kwargs) -> List[OperationResult]:
         """Enhanced VPC operations with manager interface support"""
         if operation_type.startswith("analyze_network_topology"):
             return self._analyze_network_topology_comprehensive(context, **kwargs)
         elif operation_type.startswith("generate_manager_report"):
-            return self._generate_manager_report(context, **kwargs) 
+            return self._generate_manager_report(context, **kwargs)
         elif operation_type.startswith("optimize_vpc_costs"):
             return self._optimize_vpc_costs_comprehensive(context, **kwargs)
         elif operation_type.startswith("analyze_nat_gateway_usage"):
@@ -1578,16 +1607,16 @@ class EnhancedVPCNetworkingManager(BaseOperation):
         else:
             # Fall back to base VPC operations
             return super().execute_operation(context, operation_type, **kwargs)
-    
+
     def _analyze_network_topology_comprehensive(self, context: OperationContext, **kwargs) -> List[OperationResult]:
         """
         Comprehensive network topology analysis migrated from networking_wrapper.py
         """
         result = self.create_operation_result(context, "analyze_network_topology", "vpc", "network-topology")
-        
+
         try:
             self.rich_console.print_header("Comprehensive Network Topology Analysis", "latest version")
-            
+
             topology_analysis = {
                 "timestamp": datetime.now().isoformat(),
                 "account_id": context.account_id,
@@ -1595,64 +1624,66 @@ class EnhancedVPCNetworkingManager(BaseOperation):
                 "vpc_topology": {},
                 "cost_analysis": {},
                 "optimization_opportunities": [],
-                "business_recommendations": []
+                "business_recommendations": [],
             }
-            
+
             ec2_client = self.get_client("ec2", context.region)
-            
+
             # Get comprehensive VPC data
             vpcs_response = self.execute_aws_call(ec2_client, "describe_vpcs")
             nat_response = self.execute_aws_call(ec2_client, "describe_nat_gateways")
             endpoints_response = self.execute_aws_call(ec2_client, "describe_vpc_endpoints")
-            
+
             # Process VPCs with enhanced metadata
             vpcs_data = []
             total_monthly_cost = 0
-            
+
             for vpc in vpcs_response["Vpcs"]:
                 vpc_analysis = self._analyze_vpc_comprehensive(ec2_client, vpc, context)
                 vpcs_data.append(vpc_analysis)
                 total_monthly_cost += vpc_analysis.get("estimated_monthly_cost", 0)
-                
+
             # Process NAT Gateways
             nat_gateways_data = []
             for nat in nat_response["NatGateways"]:
                 if nat["State"] != "deleted":
                     nat_analysis = self._analyze_nat_gateway_costs(ec2_client, nat, context)
                     nat_gateways_data.append(nat_analysis)
-                    
+
             # Generate business recommendations
             business_recommendations = self._generate_business_recommendations(
                 vpcs_data, nat_gateways_data, total_monthly_cost
             )
-            
-            topology_analysis.update({
-                "vpcs": vpcs_data,
-                "nat_gateways": nat_gateways_data,
-                "vpc_endpoints": self._analyze_vpc_endpoints(endpoints_response["VpcEndpoints"]),
-                "total_monthly_cost": total_monthly_cost,
-                "total_annual_cost": total_monthly_cost * 12,
-                "business_recommendations": business_recommendations
-            })
-            
+
+            topology_analysis.update(
+                {
+                    "vpcs": vpcs_data,
+                    "nat_gateways": nat_gateways_data,
+                    "vpc_endpoints": self._analyze_vpc_endpoints(endpoints_response["VpcEndpoints"]),
+                    "total_monthly_cost": total_monthly_cost,
+                    "total_annual_cost": total_monthly_cost * 12,
+                    "business_recommendations": business_recommendations,
+                }
+            )
+
             # Display results with Rich formatting
             self._display_topology_analysis(topology_analysis)
-            
+
             result.mark_completed(OperationStatus.SUCCESS)
             result.response_data = topology_analysis
-            
+
         except Exception as e:
             error_msg = f"Network topology analysis failed: {e}"
             result.mark_completed(OperationStatus.FAILED, error_msg)
             self.rich_console.print_error(f"❌ {error_msg}")
             logger.error(error_msg)
-            
+
         return [result]
-    
+
     def _analyze_vpc_comprehensive(self, ec2_client, vpc: Dict[str, Any], context: OperationContext) -> Dict[str, Any]:
         """Comprehensive VPC analysis with cost implications"""
         tags = {tag["Key"]: tag["Value"] for tag in vpc.get("Tags", [])}
-        
+
         vpc_analysis = {
             "vpc_id": vpc["VpcId"],
             "cidr_block": vpc["CidrBlock"],
@@ -1664,48 +1695,51 @@ class EnhancedVPCNetworkingManager(BaseOperation):
             "security_groups": [],
             "route_tables": [],
             "estimated_monthly_cost": 0,
-            "optimization_opportunities": []
+            "optimization_opportunities": [],
         }
-        
+
         try:
             # Get subnets
             subnets_response = self.execute_aws_call(
-                ec2_client, "describe_subnets",
-                Filters=[{"Name": "vpc-id", "Values": [vpc["VpcId"]]}]
+                ec2_client, "describe_subnets", Filters=[{"Name": "vpc-id", "Values": [vpc["VpcId"]]}]
             )
-            
+
             for subnet in subnets_response["Subnets"]:
                 subnet_tags = {tag["Key"]: tag["Value"] for tag in subnet.get("Tags", [])}
-                vpc_analysis["subnets"].append({
-                    "subnet_id": subnet["SubnetId"],
-                    "cidr_block": subnet["CidrBlock"],
-                    "availability_zone": subnet["AvailabilityZone"],
-                    "available_ip_address_count": subnet["AvailableIpAddressCount"],
-                    "map_public_ip_on_launch": subnet.get("MapPublicIpOnLaunch", False),
-                    "tags": subnet_tags,
-                    "name": subnet_tags.get("Name", subnet["SubnetId"])
-                })
-                
+                vpc_analysis["subnets"].append(
+                    {
+                        "subnet_id": subnet["SubnetId"],
+                        "cidr_block": subnet["CidrBlock"],
+                        "availability_zone": subnet["AvailabilityZone"],
+                        "available_ip_address_count": subnet["AvailableIpAddressCount"],
+                        "map_public_ip_on_launch": subnet.get("MapPublicIpOnLaunch", False),
+                        "tags": subnet_tags,
+                        "name": subnet_tags.get("Name", subnet["SubnetId"]),
+                    }
+                )
+
             # Basic cost estimation (placeholder for more sophisticated analysis)
             if len(vpc_analysis["subnets"]) > 10:
-                vpc_analysis["optimization_opportunities"].append({
-                    "type": "subnet_consolidation",
-                    "description": f"VPC has {len(vpc_analysis['subnets'])} subnets - consider consolidation",
-                    "potential_savings": "Reduced management overhead"
-                })
-                
+                vpc_analysis["optimization_opportunities"].append(
+                    {
+                        "type": "subnet_consolidation",
+                        "description": f"VPC has {len(vpc_analysis['subnets'])} subnets - consider consolidation",
+                        "potential_savings": "Reduced management overhead",
+                    }
+                )
+
         except Exception as e:
             logger.warning(f"Failed to get detailed VPC data for {vpc['VpcId']}: {e}")
-            
+
         return vpc_analysis
-    
+
     def _analyze_nat_gateway_costs(self, ec2_client, nat: Dict[str, Any], context: OperationContext) -> Dict[str, Any]:
         """Detailed NAT Gateway cost analysis"""
         tags = {tag["Key"]: tag["Value"] for tag in nat.get("Tags", [])}
-        
+
         # Base monthly cost (24/7 * 30 days * $0.045/hour)
         base_monthly_cost = 24 * 30 * self.nat_gateway_hourly_cost
-        
+
         nat_analysis = {
             "nat_gateway_id": nat["NatGatewayId"],
             "state": nat["State"],
@@ -1717,94 +1751,104 @@ class EnhancedVPCNetworkingManager(BaseOperation):
             "base_monthly_cost": base_monthly_cost,
             "estimated_data_processing_cost": 0,  # Would need CloudWatch metrics for accurate calculation
             "total_estimated_monthly_cost": base_monthly_cost,
-            "optimization_recommendation": "monitor_usage"
+            "optimization_recommendation": "monitor_usage",
         }
-        
+
         # Add optimization recommendations based on analysis
         if nat["State"] == "available":
             nat_analysis["optimization_recommendation"] = "monitor_usage"
         elif nat["State"] in ["pending", "failed"]:
             nat_analysis["optimization_recommendation"] = "investigate_health"
-            
+
         return nat_analysis
-    
+
     def _analyze_vpc_endpoints(self, endpoints: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
         """Analyze VPC endpoints with cost implications"""
         endpoints_analysis = []
-        
+
         for endpoint in endpoints:
             tags = {tag["Key"]: tag["Value"] for tag in endpoint.get("Tags", [])}
-            
+
             # Estimate monthly cost based on endpoint type
             if endpoint.get("VpcEndpointType") == "Interface":
-                estimated_monthly_cost = 24 * 30 * self.vpc_endpoint_hourly_cost  # Interface endpoints have hourly charges
+                estimated_monthly_cost = (
+                    24 * 30 * self.vpc_endpoint_hourly_cost
+                )  # Interface endpoints have hourly charges
             else:
                 estimated_monthly_cost = 0  # Gateway endpoints are typically free
-                
-            endpoints_analysis.append({
-                "vpc_endpoint_id": endpoint["VpcEndpointId"],
-                "vpc_id": endpoint.get("VpcId"),
-                "service_name": endpoint.get("ServiceName"),
-                "endpoint_type": endpoint.get("VpcEndpointType"),
-                "state": endpoint.get("State"),
-                "tags": tags,
-                "name": tags.get("Name", endpoint["VpcEndpointId"]),
-                "estimated_monthly_cost": estimated_monthly_cost,
-                "route_table_ids": endpoint.get("RouteTableIds", []),
-                "subnet_ids": endpoint.get("SubnetIds", [])
-            })
-            
+
+            endpoints_analysis.append(
+                {
+                    "vpc_endpoint_id": endpoint["VpcEndpointId"],
+                    "vpc_id": endpoint.get("VpcId"),
+                    "service_name": endpoint.get("ServiceName"),
+                    "endpoint_type": endpoint.get("VpcEndpointType"),
+                    "state": endpoint.get("State"),
+                    "tags": tags,
+                    "name": tags.get("Name", endpoint["VpcEndpointId"]),
+                    "estimated_monthly_cost": estimated_monthly_cost,
+                    "route_table_ids": endpoint.get("RouteTableIds", []),
+                    "subnet_ids": endpoint.get("SubnetIds", []),
+                }
+            )
+
         return endpoints_analysis
-    
-    def _generate_business_recommendations(self, vpcs_data: List[Dict], nat_data: List[Dict], total_cost: float) -> List[BusinessRecommendation]:
+
+    def _generate_business_recommendations(
+        self, vpcs_data: List[Dict], nat_data: List[Dict], total_cost: float
+    ) -> List[BusinessRecommendation]:
         """Generate business-focused recommendations"""
         recommendations = []
-        
+
         # NAT Gateway optimization recommendation
         active_nat_gateways = [nat for nat in nat_data if nat["state"] == "available"]
         if len(active_nat_gateways) > len(vpcs_data):
             # Dynamic NAT Gateway cost from AWS Pricing API - NO hardcoded values
             nat_gateway_monthly_cost = self._get_nat_gateway_monthly_cost()
             potential_savings = (len(active_nat_gateways) - len(vpcs_data)) * nat_gateway_monthly_cost
-            
-            recommendations.append(BusinessRecommendation(
-                title="NAT Gateway Consolidation Opportunity",
-                executive_summary=f"Multiple NAT Gateways detected ({len(active_nat_gateways)}) across {len(vpcs_data)} VPCs",
-                monthly_savings=potential_savings,
-                annual_impact=potential_savings * 12,
-                implementation_timeline="2-4 weeks",
-                business_priority=BusinessPriority.HIGH if potential_savings > 90 else BusinessPriority.MEDIUM,
-                risk_level=RiskLevel.LOW,
-                resource_requirements=["Network engineer", "1-2 hours/NAT Gateway"],
-                success_metrics=[f"Reduce monthly NAT Gateway costs by ${potential_savings:.2f}"],
-                approval_required=potential_savings > self.manager_config.approval_threshold,
-                quick_win=potential_savings > 50,
-                strategic_value="Cost optimization without service impact"
-            ))
-            
-        # VPC complexity recommendation  
+
+            recommendations.append(
+                BusinessRecommendation(
+                    title="NAT Gateway Consolidation Opportunity",
+                    executive_summary=f"Multiple NAT Gateways detected ({len(active_nat_gateways)}) across {len(vpcs_data)} VPCs",
+                    monthly_savings=potential_savings,
+                    annual_impact=potential_savings * 12,
+                    implementation_timeline="2-4 weeks",
+                    business_priority=BusinessPriority.HIGH if potential_savings > 90 else BusinessPriority.MEDIUM,
+                    risk_level=RiskLevel.LOW,
+                    resource_requirements=["Network engineer", "1-2 hours/NAT Gateway"],
+                    success_metrics=[f"Reduce monthly NAT Gateway costs by ${potential_savings:.2f}"],
+                    approval_required=potential_savings > self.manager_config.approval_threshold,
+                    quick_win=potential_savings > 50,
+                    strategic_value="Cost optimization without service impact",
+                )
+            )
+
+        # VPC complexity recommendation
         complex_vpcs = [vpc for vpc in vpcs_data if len(vpc.get("subnets", [])) > 15]
         if complex_vpcs:
-            recommendations.append(BusinessRecommendation(
-                title="VPC Architecture Simplification",
-                executive_summary=f"Detected {len(complex_vpcs)} VPCs with high subnet complexity",
-                monthly_savings=0,  # Operational savings, not direct cost
-                annual_impact=0,
-                implementation_timeline="6-12 weeks",
-                business_priority=BusinessPriority.MEDIUM,
-                risk_level=RiskLevel.MEDIUM,
-                resource_requirements=["Cloud architect", "Network engineer", "4-8 hours/VPC"],
-                success_metrics=["Reduced operational complexity", "Improved maintainability"],
-                approval_required=True,
-                quick_win=False,
-                strategic_value="Improved operational efficiency and reduced management overhead"
-            ))
-            
+            recommendations.append(
+                BusinessRecommendation(
+                    title="VPC Architecture Simplification",
+                    executive_summary=f"Detected {len(complex_vpcs)} VPCs with high subnet complexity",
+                    monthly_savings=0,  # Operational savings, not direct cost
+                    annual_impact=0,
+                    implementation_timeline="6-12 weeks",
+                    business_priority=BusinessPriority.MEDIUM,
+                    risk_level=RiskLevel.MEDIUM,
+                    resource_requirements=["Cloud architect", "Network engineer", "4-8 hours/VPC"],
+                    success_metrics=["Reduced operational complexity", "Improved maintainability"],
+                    approval_required=True,
+                    quick_win=False,
+                    strategic_value="Improved operational efficiency and reduced management overhead",
+                )
+            )
+
         return recommendations
-    
+
     def _display_topology_analysis(self, topology_analysis: Dict[str, Any]) -> None:
         """Display topology analysis with Rich formatting"""
-        
+
         # Summary panel
         summary_text = (
             f"Total VPCs: {len(topology_analysis.get('vpcs', []))}\n"
@@ -1813,44 +1857,49 @@ class EnhancedVPCNetworkingManager(BaseOperation):
             f"Estimated monthly cost: ${topology_analysis.get('total_monthly_cost', 0):.2f}\n"
             f"Estimated annual cost: ${topology_analysis.get('total_annual_cost', 0):.2f}"
         )
-        
-        self.rich_console.print_panel(
-            "Network Topology Summary",
-            summary_text,
-            title="🏗️ Infrastructure Overview"
-        )
-        
+
+        self.rich_console.print_panel("Network Topology Summary", summary_text, title="🏗️ Infrastructure Overview")
+
         # Business recommendations table
-        recommendations = topology_analysis.get('business_recommendations', [])
+        recommendations = topology_analysis.get("business_recommendations", [])
         if recommendations:
             rec_data = []
             for rec in recommendations:
-                rec_data.append([
-                    rec.title,
-                    rec.business_priority.value,
-                    f"${rec.monthly_savings:.2f}",
-                    f"${rec.annual_impact:.2f}",
-                    rec.implementation_timeline,
-                    "Yes" if rec.approval_required else "No"
-                ])
-                
+                rec_data.append(
+                    [
+                        rec.title,
+                        rec.business_priority.value,
+                        f"${rec.monthly_savings:.2f}",
+                        f"${rec.annual_impact:.2f}",
+                        rec.implementation_timeline,
+                        "Yes" if rec.approval_required else "No",
+                    ]
+                )
+
             self.rich_console.print_table(
                 rec_data,
-                headers=["Recommendation", "Priority", "Monthly Savings", "Annual Impact", "Timeline", "Approval Required"],
-                title="💡 Business Optimization Recommendations"
+                headers=[
+                    "Recommendation",
+                    "Priority",
+                    "Monthly Savings",
+                    "Annual Impact",
+                    "Timeline",
+                    "Approval Required",
+                ],
+                title="💡 Business Optimization Recommendations",
             )
-    
+
     def _generate_manager_report(self, context: OperationContext, **kwargs) -> List[OperationResult]:
         """Generate manager-friendly business report"""
         result = self.create_operation_result(context, "generate_manager_report", "vpc", "manager-report")
-        
+
         try:
             self.rich_console.print_header("Manager Dashboard - VPC Cost Optimization", "latest version")
-            
+
             # First run comprehensive analysis
             analysis_results = self._analyze_network_topology_comprehensive(context, **kwargs)
             analysis_data = analysis_results[0].response_data
-            
+
             # Generate executive summary
             executive_report = {
                 "report_generated": datetime.now().isoformat(),
@@ -1858,86 +1907,89 @@ class EnhancedVPCNetworkingManager(BaseOperation):
                     "total_infrastructure_cost": analysis_data.get("total_monthly_cost", 0),
                     "optimization_opportunities": len(analysis_data.get("business_recommendations", [])),
                     "immediate_actions": [
-                        rec for rec in analysis_data.get("business_recommendations", [])
+                        rec
+                        for rec in analysis_data.get("business_recommendations", [])
                         if rec.quick_win and rec.business_priority in [BusinessPriority.HIGH, BusinessPriority.CRITICAL]
                     ],
                     "approval_required_items": [
-                        rec for rec in analysis_data.get("business_recommendations", [])
-                        if rec.approval_required
-                    ]
+                        rec for rec in analysis_data.get("business_recommendations", []) if rec.approval_required
+                    ],
                 },
                 "detailed_analysis": analysis_data,
-                "next_steps": self._generate_next_steps(analysis_data.get("business_recommendations", []))
+                "next_steps": self._generate_next_steps(analysis_data.get("business_recommendations", [])),
             }
-            
+
             # Display executive summary
             self._display_executive_summary(executive_report["executive_summary"])
-            
+
             result.mark_completed(OperationStatus.SUCCESS)
             result.response_data = executive_report
-            
+
         except Exception as e:
             error_msg = f"Manager report generation failed: {e}"
             result.mark_completed(OperationStatus.FAILED, error_msg)
             self.rich_console.print_error(f"❌ {error_msg}")
             logger.error(error_msg)
-            
+
         return [result]
-    
+
     def _generate_next_steps(self, recommendations: List[BusinessRecommendation]) -> List[Dict[str, str]]:
         """Generate actionable next steps for managers"""
         next_steps = []
-        
+
         high_priority = [rec for rec in recommendations if rec.business_priority == BusinessPriority.HIGH]
         quick_wins = [rec for rec in recommendations if rec.quick_win]
-        
+
         if high_priority:
-            next_steps.append({
-                "action": "Review High Priority Items",
-                "description": f"Review {len(high_priority)} high-priority optimization opportunities",
-                "timeline": "This week"
-            })
-            
+            next_steps.append(
+                {
+                    "action": "Review High Priority Items",
+                    "description": f"Review {len(high_priority)} high-priority optimization opportunities",
+                    "timeline": "This week",
+                }
+            )
+
         if quick_wins:
-            next_steps.append({
-                "action": "Implement Quick Wins", 
-                "description": f"Execute {len(quick_wins)} quick-win optimizations",
-                "timeline": "Next 2 weeks"
-            })
-            
-        next_steps.append({
-            "action": "Schedule Technical Review",
-            "description": "Meet with technical team to discuss implementation details",
-            "timeline": "Within 2 weeks"
-        })
-        
+            next_steps.append(
+                {
+                    "action": "Implement Quick Wins",
+                    "description": f"Execute {len(quick_wins)} quick-win optimizations",
+                    "timeline": "Next 2 weeks",
+                }
+            )
+
+        next_steps.append(
+            {
+                "action": "Schedule Technical Review",
+                "description": "Meet with technical team to discuss implementation details",
+                "timeline": "Within 2 weeks",
+            }
+        )
+
         return next_steps
-    
+
     def _display_executive_summary(self, summary: Dict[str, Any]) -> None:
         """Display executive summary with business-friendly formatting"""
-        
+
         summary_text = (
             f"Monthly Infrastructure Cost: ${summary.get('total_infrastructure_cost', 0):.2f}\n"
             f"Optimization Opportunities: {summary.get('optimization_opportunities', 0)}\n"
             f"Quick Win Actions: {len(summary.get('immediate_actions', []))}\n"
             f"Items Requiring Approval: {len(summary.get('approval_required_items', []))}"
         )
-        
-        self.rich_console.print_panel(
-            "Executive Dashboard",
-            summary_text,
-            title="📊 Business Overview"
-        )
+
+        self.rich_console.print_panel("Executive Dashboard", summary_text, title="📊 Business Overview")
 
 
 # =============================================================================
 # AWSO-5 VPC Cleanup Operations - Enterprise Security Framework
 # =============================================================================
 
+
 @dataclass
 class VPCCleanupConfiguration:
     """AWSO-5 VPC cleanup configuration with enterprise safety controls."""
-    
+
     vpc_id: str
     dry_run: bool = True
     force_cleanup: bool = False
@@ -1945,12 +1997,12 @@ class VPCCleanupConfiguration:
     evidence_collection: bool = True
     platform_lead_approval: bool = False
     skip_eni_gate: bool = False  # DANGEROUS: Only for emergency scenarios
-    
+
     def __post_init__(self):
         """Validation of cleanup configuration."""
         if self.force_cleanup and not self.approval_token:
             raise ValueError("Force cleanup requires approval token")
-        
+
         if self.skip_eni_gate and not self.platform_lead_approval:
             raise ValueError("Skipping ENI gate requires Platform Lead approval")
 
@@ -1958,42 +2010,42 @@ class VPCCleanupConfiguration:
 @dataclass
 class VPCCleanupPlan:
     """AWSO-5 VPC cleanup execution plan with ordered steps."""
-    
+
     vpc_id: str
     cleanup_steps: List[Dict[str, Any]]
     estimated_duration_minutes: int
     risk_level: str  # LOW, MEDIUM, HIGH
     requires_approval: bool
-    
+
     # Evidence collection
     pre_cleanup_evidence: Dict[str, Any]
     plan_hash: str
     plan_timestamp: str
-    
+
     @property
     def total_steps(self) -> int:
         """Total number of cleanup steps."""
         return len(self.cleanup_steps)
-    
+
     @property
     def blocking_steps(self) -> int:
         """Number of steps that could cause service disruption."""
-        return len([step for step in self.cleanup_steps if step.get('risk_level') == 'HIGH'])
+        return len([step for step in self.cleanup_steps if step.get("risk_level") == "HIGH"])
 
 
 class AWSO5VPCCleanupOperation(BaseOperation):
     """
     AWSO-5 VPC Cleanup Operation - Enterprise Security Framework.
-    
+
     Implements comprehensive VPC cleanup following the AWSO-5 12-step framework
     with enterprise safety controls, evidence collection, and approval workflows.
-    
+
     **Strategic Alignment**:
     - Security posture enhancement through default VPC elimination
-    - Attack surface reduction via systematic dependency cleanup  
+    - Attack surface reduction via systematic dependency cleanup
     - CIS Benchmark compliance through infrastructure hygiene
     - Evidence-based validation with SHA256-verified audit trails
-    
+
     **Safety Controls**:
     - ENI gate validation (prevents accidental workload disruption)
     - Dry-run first approach with detailed execution plans
@@ -2001,52 +2053,48 @@ class AWSO5VPCCleanupOperation(BaseOperation):
     - Comprehensive rollback procedures
     - Real-time monitoring and validation
     """
-    
+
     def __init__(self, context: OperationContext):
         """Initialize AWSO-5 VPC cleanup operation."""
         super().__init__(context)
         self.operation_type = "AWSO5_VPC_CLEANUP"
-        
+
         # Initialize dependency analyzer
         from runbooks.inventory.vpc_dependency_analyzer import VPCDependencyAnalyzer
-        self.dependency_analyzer = VPCDependencyAnalyzer(
-            session=self.context.session, 
-            region=self.context.region
-        )
-        
+
+        self.dependency_analyzer = VPCDependencyAnalyzer(session=self.context.session, region=self.context.region)
+
         # Cleanup tracking
         self.cleanup_evidence: Dict[str, Any] = {}
         self.cleanup_plan: Optional[VPCCleanupPlan] = None
-    
+
     def execute_vpc_cleanup(
-        self, 
-        config: VPCCleanupConfiguration,
-        evidence_bundle_path: Optional[str] = None
+        self, config: VPCCleanupConfiguration, evidence_bundle_path: Optional[str] = None
     ) -> List[OperationResult]:
         """
         Execute AWSO-5 VPC cleanup with comprehensive safety validation.
-        
+
         Args:
             config: VPC cleanup configuration
             evidence_bundle_path: Optional path to save evidence bundle
-            
+
         Returns:
             Operation results with evidence and audit information
         """
         results = []
         operation_start = datetime.utcnow()
-        
+
         try:
             # Phase 1: Pre-cleanup Analysis & Validation
             self.rich_console.print_header("AWSO-5 VPC Cleanup Operation", "1.0.0")
             self.rich_console.print_info(f"Target VPC: {config.vpc_id}")
             self.rich_console.print_info(f"Mode: {'DRY-RUN' if config.dry_run else 'EXECUTE'}")
-            
+
             # Step 1: ENI Gate Validation (Critical Safety Check)
             if not config.skip_eni_gate:
                 self.rich_console.print_info("Step 1: ENI Gate Validation (Critical Safety Check)")
                 dependency_result = self.dependency_analyzer.analyze_vpc_dependencies(config.vpc_id)
-                
+
                 if dependency_result.eni_count > 0:
                     error_msg = f"ENI Gate FAILED: {dependency_result.eni_count} active ENIs detected"
                     self.rich_console.print_error(f"❌ {error_msg}")
@@ -2055,33 +2103,33 @@ class AWSO5VPCCleanupOperation(BaseOperation):
                     self.rich_console.print_info("1. Investigate ENI owners and workload requirements")
                     self.rich_console.print_info("2. Coordinate with application teams")
                     self.rich_console.print_info("3. Consider migration vs cleanup options")
-                    
+
                     result = OperationResult(
                         operation_id=self.context.operation_id,
                         operation_type="AWSO5_ENI_GATE_CHECK",
                         status=OperationStatus.FAILED,
                         message=error_msg,
                         details={
-                            'eni_count': dependency_result.eni_count,
-                            'vpc_id': config.vpc_id,
-                            'recommendation': 'INVESTIGATE_REQUIRED',
-                            'dependencies': [dep.__dict__ for dep in dependency_result.dependencies]
-                        }
+                            "eni_count": dependency_result.eni_count,
+                            "vpc_id": config.vpc_id,
+                            "recommendation": "INVESTIGATE_REQUIRED",
+                            "dependencies": [dep.__dict__ for dep in dependency_result.dependencies],
+                        },
                     )
                     return [result]
-                
+
                 self.rich_console.print_success("✅ ENI Gate PASSED - No active ENIs detected")
             else:
                 self.rich_console.print_warning("⚠️  ENI Gate SKIPPED (Platform Lead Approval Required)")
                 dependency_result = self.dependency_analyzer.analyze_vpc_dependencies(config.vpc_id)
-            
+
             # Step 2: Generate Cleanup Plan
             self.rich_console.print_info("Step 2: Generating Comprehensive Cleanup Plan")
             self.cleanup_plan = self._generate_cleanup_plan(dependency_result, config)
-            
+
             # Display cleanup plan
             self._display_cleanup_plan(self.cleanup_plan)
-            
+
             # Step 3: Risk Assessment & Approval Gate
             if self.cleanup_plan.requires_approval and not config.approval_token:
                 self.rich_console.print_warning("⚠️  This cleanup requires Platform Lead approval")
@@ -2090,21 +2138,21 @@ class AWSO5VPCCleanupOperation(BaseOperation):
                     self.rich_console.print_info("• Platform Lead (Default VPC deletion)")
                 if self.cleanup_plan.risk_level == "HIGH":
                     self.rich_console.print_info("• Additional stakeholder review")
-                
+
                 result = OperationResult(
                     operation_id=self.context.operation_id,
                     operation_type="AWSO5_APPROVAL_REQUIRED",
                     status=OperationStatus.PENDING_APPROVAL,
                     message="Platform Lead approval required for VPC cleanup",
                     details={
-                        'vpc_id': config.vpc_id,
-                        'risk_level': self.cleanup_plan.risk_level,
-                        'requires_approval_reason': 'Default VPC or High Risk Operation',
-                        'cleanup_plan': self.cleanup_plan.__dict__
-                    }
+                        "vpc_id": config.vpc_id,
+                        "risk_level": self.cleanup_plan.risk_level,
+                        "requires_approval_reason": "Default VPC or High Risk Operation",
+                        "cleanup_plan": self.cleanup_plan.__dict__,
+                    },
                 )
                 return [result]
-            
+
             # Step 4: Execute Cleanup (Dry-run or Actual)
             if config.dry_run:
                 self.rich_console.print_info("Step 3: DRY-RUN Mode - No actual changes will be made")
@@ -2112,86 +2160,84 @@ class AWSO5VPCCleanupOperation(BaseOperation):
             else:
                 self.rich_console.print_info("Step 3: EXECUTING VPC Cleanup")
                 result = self._execute_actual_cleanup(self.cleanup_plan, config)
-            
+
             # Step 5: Evidence Bundle Generation
             if config.evidence_collection:
                 self.rich_console.print_info("Step 4: Generating Evidence Bundle")
                 evidence_bundle = self._generate_evidence_bundle(
-                    dependency_result, 
-                    self.cleanup_plan, 
-                    result,
-                    evidence_bundle_path
+                    dependency_result, self.cleanup_plan, result, evidence_bundle_path
                 )
-                result.details['evidence_bundle'] = evidence_bundle
-            
+                result.details["evidence_bundle"] = evidence_bundle
+
             results.append(result)
-            
+
         except Exception as e:
             error_msg = f"AWSO-5 VPC cleanup failed: {str(e)}"
             logger.exception(error_msg)
-            
+
             result = OperationResult(
                 operation_id=self.context.operation_id,
                 operation_type="AWSO5_VPC_CLEANUP_ERROR",
                 status=OperationStatus.FAILED,
                 message=error_msg,
                 details={
-                    'vpc_id': config.vpc_id,
-                    'error_type': type(e).__name__,
-                    'operation_duration': (datetime.utcnow() - operation_start).total_seconds()
-                }
+                    "vpc_id": config.vpc_id,
+                    "error_type": type(e).__name__,
+                    "operation_duration": (datetime.utcnow() - operation_start).total_seconds(),
+                },
             )
             results.append(result)
-            
+
         return results
-    
-    def _generate_cleanup_plan(
-        self, 
-        dependency_result, 
-        config: VPCCleanupConfiguration
-    ) -> VPCCleanupPlan:
+
+    def _generate_cleanup_plan(self, dependency_result, config: VPCCleanupConfiguration) -> VPCCleanupPlan:
         """Generate comprehensive VPC cleanup plan based on dependency analysis."""
-        
+
         cleanup_steps = []
         risk_level = "LOW"
         estimated_duration = 5  # Base time in minutes
-        
+
         # Generate cleanup steps based on dependencies
         for dependency in dependency_result.dependencies:
             if dependency.is_blocking:
                 step = {
-                    'step_type': 'DEPENDENCY_CLEANUP',
-                    'resource_type': dependency.resource_type,
-                    'resource_id': dependency.resource_id,
-                    'action': dependency.remediation_action,
-                    'risk_level': 'HIGH' if dependency.resource_type in ['LoadBalancer', 'TransitGatewayAttachment'] else 'MEDIUM',
-                    'estimated_minutes': self._estimate_cleanup_time(dependency.resource_type)
+                    "step_type": "DEPENDENCY_CLEANUP",
+                    "resource_type": dependency.resource_type,
+                    "resource_id": dependency.resource_id,
+                    "action": dependency.remediation_action,
+                    "risk_level": "HIGH"
+                    if dependency.resource_type in ["LoadBalancer", "TransitGatewayAttachment"]
+                    else "MEDIUM",
+                    "estimated_minutes": self._estimate_cleanup_time(dependency.resource_type),
                 }
                 cleanup_steps.append(step)
-                estimated_duration += step['estimated_minutes']
-                
-                if step['risk_level'] == 'HIGH':
+                estimated_duration += step["estimated_minutes"]
+
+                if step["risk_level"] == "HIGH":
                     risk_level = "HIGH"
-                elif step['risk_level'] == 'MEDIUM' and risk_level != "HIGH":
+                elif step["risk_level"] == "MEDIUM" and risk_level != "HIGH":
                     risk_level = "MEDIUM"
-        
+
         # Final VPC deletion step
-        cleanup_steps.append({
-            'step_type': 'VPC_DELETION',
-            'resource_type': 'VPC',
-            'resource_id': config.vpc_id,
-            'action': 'Delete VPC (final step)',
-            'risk_level': 'MEDIUM',
-            'estimated_minutes': 2
-        })
+        cleanup_steps.append(
+            {
+                "step_type": "VPC_DELETION",
+                "resource_type": "VPC",
+                "resource_id": config.vpc_id,
+                "action": "Delete VPC (final step)",
+                "risk_level": "MEDIUM",
+                "estimated_minutes": 2,
+            }
+        )
         estimated_duration += 2
-        
+
         # Calculate plan hash for integrity
         import hashlib
         import json
+
         plan_content = json.dumps(cleanup_steps, sort_keys=True)
         plan_hash = hashlib.sha256(plan_content.encode()).hexdigest()
-        
+
         return VPCCleanupPlan(
             vpc_id=config.vpc_id,
             cleanup_steps=cleanup_steps,
@@ -2200,72 +2246,68 @@ class AWSO5VPCCleanupOperation(BaseOperation):
             requires_approval=dependency_result.is_default or risk_level == "HIGH",
             pre_cleanup_evidence=dependency_result.__dict__,
             plan_hash=plan_hash[:16],  # Short hash for display
-            plan_timestamp=datetime.utcnow().isoformat()
+            plan_timestamp=datetime.utcnow().isoformat(),
         )
-    
+
     def _estimate_cleanup_time(self, resource_type: str) -> int:
         """Estimate cleanup time in minutes for different resource types."""
         time_estimates = {
-            'NetworkInterface': 3,
-            'NatGateway': 5,
-            'InternetGateway': 2,
-            'RouteTable': 2,
-            'VpcEndpoint': 3,
-            'TransitGatewayAttachment': 10,
-            'VpcPeeringConnection': 3,
-            'ResolverEndpoint': 5,
-            'LoadBalancer': 8,
-            'SecurityGroup': 2,
-            'NetworkAcl': 2,
-            'FlowLog': 1
+            "NetworkInterface": 3,
+            "NatGateway": 5,
+            "InternetGateway": 2,
+            "RouteTable": 2,
+            "VpcEndpoint": 3,
+            "TransitGatewayAttachment": 10,
+            "VpcPeeringConnection": 3,
+            "ResolverEndpoint": 5,
+            "LoadBalancer": 8,
+            "SecurityGroup": 2,
+            "NetworkAcl": 2,
+            "FlowLog": 1,
         }
         return time_estimates.get(resource_type, 3)
-    
+
     def _display_cleanup_plan(self, plan: VPCCleanupPlan) -> None:
         """Display comprehensive cleanup plan with Rich formatting."""
-        
+
         # Plan Summary
-        summary_table = create_table(
-            title="AWSO-5 VPC Cleanup Plan Summary"
-        )
+        summary_table = create_table(title="AWSO-5 VPC Cleanup Plan Summary")
         summary_table.add_column("Metric", style="cyan")
         summary_table.add_column("Value", style="green")
-        
+
         summary_table.add_row("VPC ID", plan.vpc_id)
         summary_table.add_row("Total Steps", str(plan.total_steps))
         summary_table.add_row("Estimated Duration", f"{plan.estimated_duration_minutes} minutes")
         summary_table.add_row("Risk Level", plan.risk_level)
         summary_table.add_row("Requires Approval", "Yes" if plan.requires_approval else "No")
         summary_table.add_row("Plan Hash", plan.plan_hash)
-        
+
         self.rich_console.print("\n")
         self.rich_console.print(summary_table)
-        
+
         # Cleanup Steps Detail
         if plan.cleanup_steps:
-            steps_table = create_table(
-                title="Cleanup Execution Steps"
-            )
+            steps_table = create_table(title="Cleanup Execution Steps")
             steps_table.add_column("Step", style="cyan")
-            steps_table.add_column("Resource Type", style="blue") 
+            steps_table.add_column("Resource Type", style="blue")
             steps_table.add_column("Resource ID", style="green")
             steps_table.add_column("Action", style="yellow")
             steps_table.add_column("Risk", style="red")
             steps_table.add_column("Est. Time", style="magenta")
-            
+
             for i, step in enumerate(plan.cleanup_steps, 1):
                 steps_table.add_row(
                     str(i),
-                    step['resource_type'],
-                    step['resource_id'],
-                    step['action'],
-                    step['risk_level'],
-                    f"{step['estimated_minutes']}min"
+                    step["resource_type"],
+                    step["resource_id"],
+                    step["action"],
+                    step["risk_level"],
+                    f"{step['estimated_minutes']}min",
                 )
-            
+
             self.rich_console.print("\n")
             self.rich_console.print(steps_table)
-        
+
         # Risk Assessment
         if plan.risk_level == "HIGH":
             self.rich_console.print_warning("⚠️  HIGH RISK: This cleanup involves critical infrastructure components")
@@ -2273,309 +2315,300 @@ class AWSO5VPCCleanupOperation(BaseOperation):
             self.rich_console.print_info("ℹ️  MEDIUM RISK: Standard cleanup with network dependencies")
         else:
             self.rich_console.print_success("✅ LOW RISK: Straightforward cleanup with minimal dependencies")
-    
-    def _execute_dry_run_cleanup(
-        self, 
-        plan: VPCCleanupPlan, 
-        config: VPCCleanupConfiguration
-    ) -> OperationResult:
+
+    def _execute_dry_run_cleanup(self, plan: VPCCleanupPlan, config: VPCCleanupConfiguration) -> OperationResult:
         """Execute dry-run cleanup showing what would be done."""
-        
+
         self.rich_console.print_success("🔍 DRY-RUN: Simulating cleanup execution")
-        
+
         simulated_results = []
         for i, step in enumerate(plan.cleanup_steps, 1):
             self.rich_console.print_info(f"Step {i}/{plan.total_steps}: Would {step['action']}")
-            simulated_results.append({
-                'step': i,
-                'resource_type': step['resource_type'],
-                'resource_id': step['resource_id'],
-                'action': step['action'],
-                'simulated_result': 'SUCCESS',
-                'notes': 'Dry-run simulation - no actual changes made'
-            })
+            simulated_results.append(
+                {
+                    "step": i,
+                    "resource_type": step["resource_type"],
+                    "resource_id": step["resource_id"],
+                    "action": step["action"],
+                    "simulated_result": "SUCCESS",
+                    "notes": "Dry-run simulation - no actual changes made",
+                }
+            )
             time.sleep(0.5)  # Simulate processing time
-        
+
         self.rich_console.print_success("✅ DRY-RUN completed successfully")
         self.rich_console.print_info("Next Steps:")
         self.rich_console.print_info("1. Review cleanup plan and risk assessment")
         self.rich_console.print_info("2. Obtain required approvals if needed")
         self.rich_console.print_info("3. Execute with --dry-run=false when ready")
-        
+
         return OperationResult(
             operation_id=self.context.operation_id,
             operation_type="AWSO5_DRY_RUN_CLEANUP",
             status=OperationStatus.COMPLETED,
             message="Dry-run cleanup completed successfully",
             details={
-                'vpc_id': config.vpc_id,
-                'cleanup_plan': plan.__dict__,
-                'simulated_results': simulated_results,
-                'execution_mode': 'DRY_RUN'
-            }
+                "vpc_id": config.vpc_id,
+                "cleanup_plan": plan.__dict__,
+                "simulated_results": simulated_results,
+                "execution_mode": "DRY_RUN",
+            },
         )
-    
-    def _execute_actual_cleanup(
-        self, 
-        plan: VPCCleanupPlan, 
-        config: VPCCleanupConfiguration
-    ) -> OperationResult:
+
+    def _execute_actual_cleanup(self, plan: VPCCleanupPlan, config: VPCCleanupConfiguration) -> OperationResult:
         """Execute actual VPC cleanup with comprehensive error handling."""
-        
+
         self.rich_console.print_warning("⚠️  EXECUTING ACTUAL CLEANUP - This will make real changes!")
-        
+
         execution_results = []
         failed_steps = []
-        
+
         try:
             for i, step in enumerate(plan.cleanup_steps, 1):
                 self.rich_console.print_info(f"Step {i}/{plan.total_steps}: {step['action']}")
-                
+
                 try:
                     # Execute cleanup step
                     step_result = self._execute_cleanup_step(step, config)
                     execution_results.append(step_result)
-                    
-                    if step_result['success']:
+
+                    if step_result["success"]:
                         self.rich_console.print_success(f"✅ Step {i} completed: {step['resource_id']}")
                     else:
                         self.rich_console.print_error(f"❌ Step {i} failed: {step_result['error']}")
-                        failed_steps.append((i, step, step_result['error']))
-                        
+                        failed_steps.append((i, step, step_result["error"]))
+
                         # Decide whether to continue or abort
-                        if step['risk_level'] == 'HIGH':
+                        if step["risk_level"] == "HIGH":
                             self.rich_console.print_error("🛑 ABORTING: High-risk step failed")
                             break
-                
+
                 except Exception as e:
                     error_msg = f"Step {i} execution error: {str(e)}"
                     self.rich_console.print_error(f"❌ {error_msg}")
                     failed_steps.append((i, step, error_msg))
-                    
+
                     # Critical failure handling
-                    if step['risk_level'] == 'HIGH':
+                    if step["risk_level"] == "HIGH":
                         self.rich_console.print_error("🛑 CRITICAL FAILURE: Aborting cleanup")
                         break
-            
+
             # Final status assessment
             if not failed_steps:
                 status = OperationStatus.COMPLETED
                 message = "AWSO-5 VPC cleanup completed successfully"
                 self.rich_console.print_success("✅ All cleanup steps completed successfully")
             elif len(failed_steps) < len(plan.cleanup_steps) // 2:
-                status = OperationStatus.PARTIALLY_COMPLETED  
+                status = OperationStatus.PARTIALLY_COMPLETED
                 message = f"VPC cleanup partially completed ({len(failed_steps)} steps failed)"
                 self.rich_console.print_warning(f"⚠️  Partial completion: {len(failed_steps)} steps failed")
             else:
                 status = OperationStatus.FAILED
                 message = f"VPC cleanup failed ({len(failed_steps)} steps failed)"
                 self.rich_console.print_error(f"❌ Cleanup failed: {len(failed_steps)} steps failed")
-            
+
             # Post-cleanup validation
             self.rich_console.print_info("Performing post-cleanup validation...")
             post_validation = self._perform_post_cleanup_validation(config.vpc_id)
-            
+
             return OperationResult(
                 operation_id=self.context.operation_id,
                 operation_type="AWSO5_ACTUAL_CLEANUP",
                 status=status,
                 message=message,
                 details={
-                    'vpc_id': config.vpc_id,
-                    'cleanup_plan': plan.__dict__,
-                    'execution_results': execution_results,
-                    'failed_steps': failed_steps,
-                    'post_validation': post_validation,
-                    'execution_mode': 'ACTUAL'
-                }
+                    "vpc_id": config.vpc_id,
+                    "cleanup_plan": plan.__dict__,
+                    "execution_results": execution_results,
+                    "failed_steps": failed_steps,
+                    "post_validation": post_validation,
+                    "execution_mode": "ACTUAL",
+                },
             )
-            
+
         except Exception as e:
             error_msg = f"Critical cleanup error: {str(e)}"
             logger.exception(error_msg)
-            
+
             return OperationResult(
                 operation_id=self.context.operation_id,
                 operation_type="AWSO5_CLEANUP_ERROR",
                 status=OperationStatus.FAILED,
                 message=error_msg,
-                details={
-                    'vpc_id': config.vpc_id,
-                    'error_type': type(e).__name__,
-                    'partial_results': execution_results
-                }
+                details={"vpc_id": config.vpc_id, "error_type": type(e).__name__, "partial_results": execution_results},
             )
-    
+
     def _execute_cleanup_step(self, step: Dict[str, Any], config: VPCCleanupConfiguration) -> Dict[str, Any]:
         """Execute a single cleanup step with AWS API calls."""
-        
-        resource_type = step['resource_type']
-        resource_id = step['resource_id']
-        
+
+        resource_type = step["resource_type"]
+        resource_id = step["resource_id"]
+
         try:
-            if resource_type == 'NatGateway':
-                self.context.session.client('ec2').delete_nat_gateway(NatGatewayId=resource_id)
-                
-            elif resource_type == 'InternetGateway':
-                ec2 = self.context.session.client('ec2')
+            if resource_type == "NatGateway":
+                self.context.session.client("ec2").delete_nat_gateway(NatGatewayId=resource_id)
+
+            elif resource_type == "InternetGateway":
+                ec2 = self.context.session.client("ec2")
                 # First detach, then delete
                 ec2.detach_internet_gateway(InternetGatewayId=resource_id, VpcId=config.vpc_id)
                 ec2.delete_internet_gateway(InternetGatewayId=resource_id)
-                
-            elif resource_type == 'RouteTable':
-                ec2 = self.context.session.client('ec2')
+
+            elif resource_type == "RouteTable":
+                ec2 = self.context.session.client("ec2")
                 # Disassociate first, then delete
-                route_tables = ec2.describe_route_tables(RouteTableIds=[resource_id])['RouteTables']
+                route_tables = ec2.describe_route_tables(RouteTableIds=[resource_id])["RouteTables"]
                 for rt in route_tables:
-                    for assoc in rt.get('Associations', []):
-                        if not assoc.get('Main'):
-                            ec2.disassociate_route_table(AssociationId=assoc['RouteTableAssociationId'])
+                    for assoc in rt.get("Associations", []):
+                        if not assoc.get("Main"):
+                            ec2.disassociate_route_table(AssociationId=assoc["RouteTableAssociationId"])
                 ec2.delete_route_table(RouteTableId=resource_id)
-                
-            elif resource_type == 'VpcEndpoint':
-                self.context.session.client('ec2').delete_vpc_endpoints(VpcEndpointIds=[resource_id])
-                
-            elif resource_type == 'TransitGatewayAttachment':
-                self.context.session.client('ec2').delete_transit_gateway_vpc_attachment(
+
+            elif resource_type == "VpcEndpoint":
+                self.context.session.client("ec2").delete_vpc_endpoints(VpcEndpointIds=[resource_id])
+
+            elif resource_type == "TransitGatewayAttachment":
+                self.context.session.client("ec2").delete_transit_gateway_vpc_attachment(
                     TransitGatewayAttachmentId=resource_id
                 )
-                
-            elif resource_type == 'VpcPeeringConnection':
-                self.context.session.client('ec2').delete_vpc_peering_connection(
-                    VpcPeeringConnectionId=resource_id
-                )
-                
-            elif resource_type == 'LoadBalancer':
-                self.context.session.client('elbv2').delete_load_balancer(LoadBalancerArn=resource_id)
-                
-            elif resource_type == 'SecurityGroup':
-                self.context.session.client('ec2').delete_security_group(GroupId=resource_id)
-                
-            elif resource_type == 'NetworkAcl':
-                self.context.session.client('ec2').delete_network_acl(NetworkAclId=resource_id)
-                
-            elif resource_type == 'FlowLog':
-                self.context.session.client('ec2').delete_flow_logs(FlowLogIds=[resource_id])
-                
-            elif resource_type == 'VPC':
+
+            elif resource_type == "VpcPeeringConnection":
+                self.context.session.client("ec2").delete_vpc_peering_connection(VpcPeeringConnectionId=resource_id)
+
+            elif resource_type == "LoadBalancer":
+                self.context.session.client("elbv2").delete_load_balancer(LoadBalancerArn=resource_id)
+
+            elif resource_type == "SecurityGroup":
+                self.context.session.client("ec2").delete_security_group(GroupId=resource_id)
+
+            elif resource_type == "NetworkAcl":
+                self.context.session.client("ec2").delete_network_acl(NetworkAclId=resource_id)
+
+            elif resource_type == "FlowLog":
+                self.context.session.client("ec2").delete_flow_logs(FlowLogIds=[resource_id])
+
+            elif resource_type == "VPC":
                 # Final VPC deletion
-                self.context.session.client('ec2').delete_vpc(VpcId=resource_id)
-                
+                self.context.session.client("ec2").delete_vpc(VpcId=resource_id)
+
             else:
                 return {
-                    'success': False,
-                    'resource_type': resource_type,
-                    'resource_id': resource_id,
-                    'error': f'Unknown resource type: {resource_type}'
+                    "success": False,
+                    "resource_type": resource_type,
+                    "resource_id": resource_id,
+                    "error": f"Unknown resource type: {resource_type}",
                 }
-            
+
             return {
-                'success': True,
-                'resource_type': resource_type,
-                'resource_id': resource_id,
-                'timestamp': datetime.utcnow().isoformat()
+                "success": True,
+                "resource_type": resource_type,
+                "resource_id": resource_id,
+                "timestamp": datetime.utcnow().isoformat(),
             }
-            
+
         except ClientError as e:
             return {
-                'success': False,
-                'resource_type': resource_type,
-                'resource_id': resource_id,
-                'error': f'AWS API Error: {e.response["Error"]["Code"]} - {e.response["Error"]["Message"]}'
+                "success": False,
+                "resource_type": resource_type,
+                "resource_id": resource_id,
+                "error": f"AWS API Error: {e.response['Error']['Code']} - {e.response['Error']['Message']}",
             }
-    
+
     def _perform_post_cleanup_validation(self, vpc_id: str) -> Dict[str, Any]:
         """Perform post-cleanup validation to ensure VPC and dependencies are removed."""
-        
+
         validation_results = {
-            'vpc_exists': False,
-            'dependencies_remaining': [],
-            'validation_timestamp': datetime.utcnow().isoformat(),
-            'validation_passed': False
+            "vpc_exists": False,
+            "dependencies_remaining": [],
+            "validation_timestamp": datetime.utcnow().isoformat(),
+            "validation_passed": False,
         }
-        
+
         try:
             # Check if VPC still exists
-            ec2 = self.context.session.client('ec2')
+            ec2 = self.context.session.client("ec2")
             try:
                 response = ec2.describe_vpcs(VpcIds=[vpc_id])
-                if response['Vpcs']:
-                    validation_results['vpc_exists'] = True
+                if response["Vpcs"]:
+                    validation_results["vpc_exists"] = True
                     self.rich_console.print_warning(f"⚠️  VPC {vpc_id} still exists")
             except ClientError as e:
-                if 'InvalidVpcID.NotFound' in str(e):
-                    validation_results['vpc_exists'] = False
+                if "InvalidVpcID.NotFound" in str(e):
+                    validation_results["vpc_exists"] = False
                     self.rich_console.print_success(f"✅ VPC {vpc_id} successfully deleted")
                 else:
                     raise
-            
+
             # Check for remaining dependencies
-            if not validation_results['vpc_exists']:
-                validation_results['validation_passed'] = True
+            if not validation_results["vpc_exists"]:
+                validation_results["validation_passed"] = True
                 self.rich_console.print_success("✅ Post-cleanup validation PASSED")
             else:
                 # Re-run dependency analysis
                 dependency_result = self.dependency_analyzer.analyze_vpc_dependencies(vpc_id)
-                validation_results['dependencies_remaining'] = [
-                    dep.__dict__ for dep in dependency_result.dependencies
-                ]
-                validation_results['validation_passed'] = len(dependency_result.dependencies) == 0
-                
-                if validation_results['validation_passed']:
+                validation_results["dependencies_remaining"] = [dep.__dict__ for dep in dependency_result.dependencies]
+                validation_results["validation_passed"] = len(dependency_result.dependencies) == 0
+
+                if validation_results["validation_passed"]:
                     self.rich_console.print_success("✅ Post-cleanup validation PASSED - No dependencies remain")
                 else:
-                    self.rich_console.print_warning(f"⚠️  {len(dependency_result.dependencies)} dependencies still exist")
-            
+                    self.rich_console.print_warning(
+                        f"⚠️  {len(dependency_result.dependencies)} dependencies still exist"
+                    )
+
         except Exception as e:
-            validation_results['error'] = str(e)
-            validation_results['validation_passed'] = False
+            validation_results["error"] = str(e)
+            validation_results["validation_passed"] = False
             self.rich_console.print_error(f"❌ Post-cleanup validation failed: {str(e)}")
-        
+
         return validation_results
-    
+
     def _generate_evidence_bundle(
         self,
         dependency_result,
         cleanup_plan: VPCCleanupPlan,
         execution_result: OperationResult,
-        evidence_bundle_path: Optional[str] = None
+        evidence_bundle_path: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Generate comprehensive evidence bundle for AWSO-5 compliance."""
-        
+
         evidence_bundle = {
-            'metadata': {
-                'framework': 'AWSO-5',
-                'version': '1.0.0',
-                'vpc_id': cleanup_plan.vpc_id,
-                'timestamp': datetime.utcnow().isoformat(),
-                'analyst': 'AWSO5VPCCleanupOperation',
-                'operation_id': self.context.operation_id
+            "metadata": {
+                "framework": "AWSO-5",
+                "version": "1.0.0",
+                "vpc_id": cleanup_plan.vpc_id,
+                "timestamp": datetime.utcnow().isoformat(),
+                "analyst": "AWSO5VPCCleanupOperation",
+                "operation_id": self.context.operation_id,
+            },
+            "pre_cleanup_analysis": dependency_result.__dict__,
+            "cleanup_plan": cleanup_plan.__dict__,
+            "execution_results": execution_result.details,
+            "evidence_artifacts": [],
+            "compliance_validation": {
+                "cis_benchmark_improvement": dependency_result.is_default,
+                "attack_surface_reduction": True if execution_result.status == OperationStatus.COMPLETED else False,
+                "security_posture_enhancement": len(dependency_result.dependencies) == 0,
             },
-            'pre_cleanup_analysis': dependency_result.__dict__,
-            'cleanup_plan': cleanup_plan.__dict__,
-            'execution_results': execution_result.details,
-            'evidence_artifacts': [],
-            'compliance_validation': {
-                'cis_benchmark_improvement': dependency_result.is_default,
-                'attack_surface_reduction': True if execution_result.status == OperationStatus.COMPLETED else False,
-                'security_posture_enhancement': len(dependency_result.dependencies) == 0
-            }
         }
-        
+
         # Calculate evidence bundle hash
         import hashlib
         import json
+
         bundle_content = json.dumps(evidence_bundle, sort_keys=True, default=str)
-        evidence_bundle['bundle_hash'] = hashlib.sha256(bundle_content.encode()).hexdigest()
-        
+        evidence_bundle["bundle_hash"] = hashlib.sha256(bundle_content.encode()).hexdigest()
+
         # Save evidence bundle if path provided
         if evidence_bundle_path:
-            with open(evidence_bundle_path, 'w') as f:
+            with open(evidence_bundle_path, "w") as f:
                 json.dump(evidence_bundle, f, indent=2, default=str)
             self.rich_console.print_success(f"Evidence bundle saved: {evidence_bundle_path}")
-        
-        self.rich_console.print_success(f"Evidence bundle generated with hash: {evidence_bundle['bundle_hash'][:16]}...")
-        
+
+        self.rich_console.print_success(
+            f"Evidence bundle generated with hash: {evidence_bundle['bundle_hash'][:16]}..."
+        )
+
         return evidence_bundle
 
 
@@ -2585,11 +2618,11 @@ def execute_vpc_cleanup(
     region: str = "us-east-1",
     dry_run: bool = True,
     approval_token: Optional[str] = None,
-    evidence_bundle_path: Optional[str] = None
+    evidence_bundle_path: Optional[str] = None,
 ) -> List[OperationResult]:
     """
     CLI wrapper for AWSO-5 VPC cleanup operation.
-    
+
     Args:
         vpc_id: AWS VPC identifier to cleanup
         profile: AWS profile name
@@ -2597,28 +2630,25 @@ def execute_vpc_cleanup(
         dry_run: Execute in dry-run mode (default: True)
         approval_token: Platform lead approval token
         evidence_bundle_path: Path to save evidence bundle
-        
+
     Returns:
         Operation results with comprehensive cleanup information
     """
     session = boto3.Session(profile_name=profile) if profile else boto3.Session()
-    
+
     # Create operation context
     context = OperationContext(
         operation_id=f"awso5-cleanup-{vpc_id}-{int(datetime.utcnow().timestamp())}",
         region=region,
         session=session,
-        dry_run=dry_run
+        dry_run=dry_run,
     )
-    
+
     # Create cleanup configuration
     config = VPCCleanupConfiguration(
-        vpc_id=vpc_id,
-        dry_run=dry_run,
-        approval_token=approval_token,
-        evidence_collection=True
+        vpc_id=vpc_id, dry_run=dry_run, approval_token=approval_token, evidence_collection=True
     )
-    
+
     # Execute cleanup operation
     cleanup_operation = AWSO5VPCCleanupOperation(context)
     return cleanup_operation.execute_vpc_cleanup(config, evidence_bundle_path)