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

runbooks/inventory/mcp_vpc_validator.py

@@ -40,8 +40,14 @@ import boto3
 from botocore.exceptions import ClientError
 
 from runbooks.common.rich_utils import (
-    console, print_header, print_success, print_error, print_warning,
-    create_table, create_progress_bar, STATUS_INDICATORS
+    console,
+    print_header,
+    print_success,
+    print_error,
+    print_warning,
+    create_table,
+    create_progress_bar,
+    STATUS_INDICATORS,
 )
 
 logger = logging.getLogger(__name__)
@@ -50,7 +56,7 @@ logger = logging.getLogger(__name__)
 @dataclass
 class MCPValidationResult:
     """MCP validation result for a specific validation check."""
-    
+
     validation_type: str  # dependency, architecture, cost, etc.
     check_name: str
     runbooks_value: Any
@@ -59,7 +65,7 @@ class MCPValidationResult:
     validation_status: str  # PASS, FAIL, WARNING, UNKNOWN
     variance_details: Dict[str, Any] = field(default_factory=dict)
     validation_timestamp: str = field(default_factory=lambda: datetime.utcnow().isoformat())
-    
+
     @property
     def meets_enterprise_standard(self) -> bool:
         """True if validation meets ≥99.5% accuracy requirement."""
@@ -69,206 +75,195 @@ class MCPValidationResult:
 @dataclass
 class AWSO5MCPValidationReport:
     """Comprehensive AWSO-5 MCP validation report."""
-    
+
     vpc_id: str
     account_id: str
     region: str
-    
+
     # Validation results by category
     dependency_validation: List[MCPValidationResult] = field(default_factory=list)
     architecture_validation: List[MCPValidationResult] = field(default_factory=list)
     cost_validation: List[MCPValidationResult] = field(default_factory=list)
     security_validation: List[MCPValidationResult] = field(default_factory=list)
-    
+
     # Overall metrics
     overall_accuracy: float = 0.0
     validation_status: str = "IN_PROGRESS"  # IN_PROGRESS, PASSED, FAILED, WARNING
     total_validations: int = 0
     passed_validations: int = 0
     failed_validations: int = 0
-    
+
     # Evidence and compliance
     evidence_artifacts: List[Dict[str, Any]] = field(default_factory=list)
     validation_hash: str = ""
     compliance_status: Dict[str, str] = field(default_factory=dict)
-    
+
     # Analysis metadata
     validation_timestamp: str = field(default_factory=lambda: datetime.utcnow().isoformat())
     validation_duration_seconds: float = 0.0
-    
+
     @property
     def meets_enterprise_accuracy(self) -> bool:
         """True if overall validation meets ≥99.5% accuracy requirement."""
         return self.overall_accuracy >= 99.5
-    
+
     @property
     def validation_summary(self) -> str:
         """Human-readable validation summary."""
-        return f"{self.passed_validations}/{self.total_validations} checks passed ({self.overall_accuracy:.2f}% accuracy)"
+        return (
+            f"{self.passed_validations}/{self.total_validations} checks passed ({self.overall_accuracy:.2f}% accuracy)"
+        )
 
 
 class AWSO5MCPValidator:
     """
     AWSO-5 MCP Validation Framework.
-    
+
     Enterprise-grade MCP validation framework implementing comprehensive
     cross-validation against AWS APIs with ≥99.5% accuracy requirements
     and evidence bundle generation for AWSO-5 compliance.
-    
+
     **Enterprise Integration**:
     - Real-time AWS API cross-validation
-    - SHA256-verified evidence bundle generation  
+    - SHA256-verified evidence bundle generation
     - PDCA quality gates with comprehensive analysis
     - Multi-dimensional validation framework
     - Regulatory compliance audit trail generation
     """
-    
+
     def __init__(self, session: Optional[boto3.Session] = None, region: str = "us-east-1"):
         """Initialize AWSO-5 MCP validator."""
         self.session = session or boto3.Session()
         self.region = region
         self.console = console
-        
+
         # Initialize AWS clients for validation
         self._ec2_client = None
         self._elbv2_client = None
         self._route53resolver_client = None
         self._cost_explorer_client = None
         self._organizations_client = None
-        
+
         # Validation tracking
         self.validation_reports: Dict[str, AWSO5MCPValidationReport] = {}
         self.evidence_collector: List[Dict[str, Any]] = []
-        
+
     @property
     def ec2_client(self):
         """Lazy-loaded EC2 client for validation."""
         if not self._ec2_client:
-            self._ec2_client = self.session.client('ec2', region_name=self.region)
+            self._ec2_client = self.session.client("ec2", region_name=self.region)
         return self._ec2_client
-    
-    @property 
+
+    @property
     def elbv2_client(self):
         """Lazy-loaded ELBv2 client for validation."""
         if not self._elbv2_client:
-            self._elbv2_client = self.session.client('elbv2', region_name=self.region)
+            self._elbv2_client = self.session.client("elbv2", region_name=self.region)
         return self._elbv2_client
-    
+
     @property
     def route53resolver_client(self):
         """Lazy-loaded Route53 Resolver client for validation."""
         if not self._route53resolver_client:
-            self._route53resolver_client = self.session.client('route53resolver', region_name=self.region)
+            self._route53resolver_client = self.session.client("route53resolver", region_name=self.region)
         return self._route53resolver_client
-    
+
     @property
     def cost_explorer_client(self):
         """Lazy-loaded Cost Explorer client for validation."""
         if not self._cost_explorer_client:
             # Cost Explorer is only available in us-east-1
-            self._cost_explorer_client = self.session.client('ce', region_name='us-east-1')
+            self._cost_explorer_client = self.session.client("ce", region_name="us-east-1")
         return self._cost_explorer_client
-    
+
     @property
     def organizations_client(self):
         """Lazy-loaded Organizations client for validation."""
         if not self._organizations_client:
             # Organizations is only available in us-east-1
-            self._organizations_client = self.session.client('organizations', region_name='us-east-1')
+            self._organizations_client = self.session.client("organizations", region_name="us-east-1")
         return self._organizations_client
-    
+
     def comprehensive_vpc_validation(
-        self, 
-        vpc_id: str, 
-        dependency_result: Any, 
-        architecture_result: Any,
-        evidence_bundle_path: Optional[str] = None
+        self, vpc_id: str, dependency_result: Any, architecture_result: Any, evidence_bundle_path: Optional[str] = None
     ) -> AWSO5MCPValidationReport:
         """
         Comprehensive VPC validation with ≥99.5% accuracy requirement.
-        
+
         Cross-validates all AWSO-5 analysis results against real-time AWS APIs
         with enterprise quality gates and evidence bundle generation.
-        
+
         Args:
             vpc_id: AWS VPC identifier
             dependency_result: VPC dependency analysis results
-            architecture_result: Architecture validation results  
+            architecture_result: Architecture validation results
             evidence_bundle_path: Optional path to save evidence bundle
-            
+
         Returns:
             Comprehensive MCP validation report with quality metrics
         """
         start_time = datetime.utcnow()
-        
-        account_id = self.session.client('sts').get_caller_identity()['Account']
-        
-        report = AWSO5MCPValidationReport(
-            vpc_id=vpc_id,
-            account_id=account_id,
-            region=self.region
-        )
-        
+
+        account_id = self.session.client("sts").get_caller_identity()["Account"]
+
+        report = AWSO5MCPValidationReport(vpc_id=vpc_id, account_id=account_id, region=self.region)
+
         print_header("AWSO-5 MCP Validation Framework", "1.0.0")
         self.console.print(f"\n[blue]MCP Cross-Validation:[/blue] {vpc_id}")
         self.console.print(f"[blue]Accuracy Target:[/blue] ≥99.5% (Enterprise Standard)")
         self.console.print(f"[blue]Validation Scope:[/blue] Comprehensive Multi-Dimensional")
-        
+
         # Phase 1: Dependency Validation
         self.console.print("\n[yellow]Phase 1: Dependency Analysis MCP Validation[/yellow]")
         self._validate_dependency_analysis(vpc_id, dependency_result, report)
-        
+
         # Phase 2: Architecture Validation
         self.console.print("\n[yellow]Phase 2: Architecture Compliance MCP Validation[/yellow]")
         self._validate_architecture_analysis(vpc_id, architecture_result, report)
-        
-        # Phase 3: Cost Impact Validation 
+
+        # Phase 3: Cost Impact Validation
         self.console.print("\n[yellow]Phase 3: Cost Impact MCP Validation[/yellow]")
         self._validate_cost_impact(vpc_id, dependency_result, report)
-        
+
         # Phase 4: Security Posture Validation
         self.console.print("\n[yellow]Phase 4: Security Posture MCP Validation[/yellow]")
         self._validate_security_posture(vpc_id, architecture_result, report)
-        
+
         # Calculate final validation metrics
         end_time = datetime.utcnow()
         report.validation_duration_seconds = (end_time - start_time).total_seconds()
         self._calculate_validation_metrics(report)
-        
+
         # Generate validation hash for evidence
         report.validation_hash = self._generate_validation_hash(report)
-        
+
         # Generate evidence bundle
         if evidence_bundle_path:
             self._generate_evidence_bundle(report, evidence_bundle_path)
-        
+
         # Store results
         self.validation_reports[vpc_id] = report
-        
+
         # Display comprehensive validation results
         self._display_validation_results(report)
-        
+
         return report
-    
-    def _validate_dependency_analysis(
-        self, 
-        vpc_id: str, 
-        dependency_result: Any, 
-        report: AWSO5MCPValidationReport
-    ):
+
+    def _validate_dependency_analysis(self, vpc_id: str, dependency_result: Any, report: AWSO5MCPValidationReport):
         """Validate dependency analysis against real AWS APIs."""
-        
+
         # Validation 1: ENI Count Cross-Check
         try:
-            mcp_enis = self.ec2_client.describe_network_interfaces(
-                Filters=[{'Name': 'vpc-id', 'Values': [vpc_id]}]
-            )['NetworkInterfaces']
-            
+            mcp_enis = self.ec2_client.describe_network_interfaces(Filters=[{"Name": "vpc-id", "Values": [vpc_id]}])[
+                "NetworkInterfaces"
+            ]
+
             mcp_eni_count = len(mcp_enis)
             runbooks_eni_count = dependency_result.eni_count
-            
+
             accuracy = self._calculate_accuracy(runbooks_eni_count, mcp_eni_count)
-            
+
             validation_result = MCPValidationResult(
                 validation_type="dependency",
                 check_name="ENI Count Validation",
@@ -277,62 +272,53 @@ class AWSO5MCPValidator:
                 accuracy_percentage=accuracy,
                 validation_status="PASS" if accuracy >= 99.5 else "FAIL",
                 variance_details={
-                    'difference': abs(runbooks_eni_count - mcp_eni_count),
-                    'percentage_variance': 100 - accuracy
-                }
+                    "difference": abs(runbooks_eni_count - mcp_eni_count),
+                    "percentage_variance": 100 - accuracy,
+                },
             )
-            
+
             report.dependency_validation.append(validation_result)
-            
+
             if accuracy >= 99.5:
-                self.console.print(f"  ✅ ENI Count: {accuracy:.2f}% accuracy (Runbooks: {runbooks_eni_count}, MCP: {mcp_eni_count})")
+                self.console.print(
+                    f"  ✅ ENI Count: {accuracy:.2f}% accuracy (Runbooks: {runbooks_eni_count}, MCP: {mcp_eni_count})"
+                )
             else:
                 self.console.print(f"  ❌ ENI Count: {accuracy:.2f}% accuracy (Variance detected)")
-                
+
         except ClientError as e:
             print_warning(f"ENI validation failed: {e}")
-        
+
         # Validation 2: NAT Gateway Dependencies
         self._validate_nat_gateways(vpc_id, dependency_result, report)
-        
+
         # Validation 3: Internet Gateway Dependencies
         self._validate_internet_gateways(vpc_id, dependency_result, report)
-        
+
         # Validation 4: Route Tables Dependencies
         self._validate_route_tables(vpc_id, dependency_result, report)
-        
+
         # Validation 5: VPC Endpoints Dependencies
         self._validate_vpc_endpoints(vpc_id, dependency_result, report)
-        
+
         # Validation 6: Load Balancer Dependencies
         self._validate_load_balancers(vpc_id, dependency_result, report)
-    
-    def _validate_nat_gateways(
-        self, 
-        vpc_id: str, 
-        dependency_result: Any, 
-        report: AWSO5MCPValidationReport
-    ):
+
+    def _validate_nat_gateways(self, vpc_id: str, dependency_result: Any, report: AWSO5MCPValidationReport):
         """Validate NAT Gateway dependency analysis."""
         try:
-            mcp_nat_gateways = self.ec2_client.describe_nat_gateways(
-                Filters=[{'Name': 'vpc-id', 'Values': [vpc_id]}]
-            )['NatGateways']
-            
-            # Count active NAT Gateways
-            active_nat_gateways = [
-                ng for ng in mcp_nat_gateways 
-                if ng['State'] in ['available', 'pending']
+            mcp_nat_gateways = self.ec2_client.describe_nat_gateways(Filters=[{"Name": "vpc-id", "Values": [vpc_id]}])[
+                "NatGateways"
             ]
-            
+
+            # Count active NAT Gateways
+            active_nat_gateways = [ng for ng in mcp_nat_gateways if ng["State"] in ["available", "pending"]]
+
             mcp_count = len(active_nat_gateways)
-            runbooks_count = len([
-                dep for dep in dependency_result.dependencies
-                if dep.resource_type == 'NatGateway'
-            ])
-            
+            runbooks_count = len([dep for dep in dependency_result.dependencies if dep.resource_type == "NatGateway"])
+
             accuracy = self._calculate_accuracy(runbooks_count, mcp_count)
-            
+
             validation_result = MCPValidationResult(
                 validation_type="dependency",
                 check_name="NAT Gateway Dependencies",
@@ -340,294 +326,243 @@ class AWSO5MCPValidator:
                 mcp_value=mcp_count,
                 accuracy_percentage=accuracy,
                 validation_status="PASS" if accuracy >= 99.5 else "FAIL",
-                variance_details={
-                    'nat_gateway_ids': [ng['NatGatewayId'] for ng in active_nat_gateways]
-                }
+                variance_details={"nat_gateway_ids": [ng["NatGatewayId"] for ng in active_nat_gateways]},
             )
-            
+
             report.dependency_validation.append(validation_result)
-            
+
             if accuracy >= 99.5:
                 self.console.print(f"  ✅ NAT Gateways: {accuracy:.2f}% accuracy")
             else:
                 self.console.print(f"  ❌ NAT Gateways: {accuracy:.2f}% accuracy (Variance detected)")
-                
+
         except ClientError as e:
             print_warning(f"NAT Gateway validation failed: {e}")
-    
-    def _validate_internet_gateways(
-        self, 
-        vpc_id: str, 
-        dependency_result: Any, 
-        report: AWSO5MCPValidationReport
-    ):
+
+    def _validate_internet_gateways(self, vpc_id: str, dependency_result: Any, report: AWSO5MCPValidationReport):
         """Validate Internet Gateway dependency analysis."""
         try:
             mcp_internet_gateways = self.ec2_client.describe_internet_gateways(
-                Filters=[{'Name': 'attachment.vpc-id', 'Values': [vpc_id]}]
-            )['InternetGateways']
-            
+                Filters=[{"Name": "attachment.vpc-id", "Values": [vpc_id]}]
+            )["InternetGateways"]
+
             mcp_count = len(mcp_internet_gateways)
-            runbooks_count = len([
-                dep for dep in dependency_result.dependencies
-                if dep.resource_type == 'InternetGateway'
-            ])
-            
+            runbooks_count = len(
+                [dep for dep in dependency_result.dependencies if dep.resource_type == "InternetGateway"]
+            )
+
             accuracy = self._calculate_accuracy(runbooks_count, mcp_count)
-            
+
             validation_result = MCPValidationResult(
                 validation_type="dependency",
                 check_name="Internet Gateway Dependencies",
                 runbooks_value=runbooks_count,
                 mcp_value=mcp_count,
                 accuracy_percentage=accuracy,
-                validation_status="PASS" if accuracy >= 99.5 else "FAIL"
+                validation_status="PASS" if accuracy >= 99.5 else "FAIL",
             )
-            
+
             report.dependency_validation.append(validation_result)
-            
+
             if accuracy >= 99.5:
                 self.console.print(f"  ✅ Internet Gateways: {accuracy:.2f}% accuracy")
             else:
                 self.console.print(f"  ❌ Internet Gateways: {accuracy:.2f}% accuracy")
-                
+
         except ClientError as e:
             print_warning(f"Internet Gateway validation failed: {e}")
-    
-    def _validate_route_tables(
-        self, 
-        vpc_id: str, 
-        dependency_result: Any, 
-        report: AWSO5MCPValidationReport
-    ):
+
+    def _validate_route_tables(self, vpc_id: str, dependency_result: Any, report: AWSO5MCPValidationReport):
         """Validate Route Table dependency analysis."""
         try:
-            mcp_route_tables = self.ec2_client.describe_route_tables(
-                Filters=[{'Name': 'vpc-id', 'Values': [vpc_id]}]
-            )['RouteTables']
-            
+            mcp_route_tables = self.ec2_client.describe_route_tables(Filters=[{"Name": "vpc-id", "Values": [vpc_id]}])[
+                "RouteTables"
+            ]
+
             # Count non-main route tables (main RT is auto-deleted)
             non_main_route_tables = [
-                rt for rt in mcp_route_tables
-                if not any(assoc.get('Main') for assoc in rt.get('Associations', []))
+                rt for rt in mcp_route_tables if not any(assoc.get("Main") for assoc in rt.get("Associations", []))
             ]
-            
+
             mcp_count = len(non_main_route_tables)
-            runbooks_count = len([
-                dep for dep in dependency_result.dependencies
-                if dep.resource_type == 'RouteTable'
-            ])
-            
+            runbooks_count = len([dep for dep in dependency_result.dependencies if dep.resource_type == "RouteTable"])
+
             accuracy = self._calculate_accuracy(runbooks_count, mcp_count)
-            
+
             validation_result = MCPValidationResult(
                 validation_type="dependency",
-                check_name="Route Table Dependencies", 
+                check_name="Route Table Dependencies",
                 runbooks_value=runbooks_count,
                 mcp_value=mcp_count,
                 accuracy_percentage=accuracy,
-                validation_status="PASS" if accuracy >= 99.5 else "FAIL"
+                validation_status="PASS" if accuracy >= 99.5 else "FAIL",
             )
-            
+
             report.dependency_validation.append(validation_result)
-            
+
             if accuracy >= 99.5:
                 self.console.print(f"  ✅ Route Tables: {accuracy:.2f}% accuracy")
             else:
                 self.console.print(f"  ❌ Route Tables: {accuracy:.2f}% accuracy")
-                
+
         except ClientError as e:
             print_warning(f"Route Table validation failed: {e}")
-    
-    def _validate_vpc_endpoints(
-        self, 
-        vpc_id: str, 
-        dependency_result: Any, 
-        report: AWSO5MCPValidationReport
-    ):
+
+    def _validate_vpc_endpoints(self, vpc_id: str, dependency_result: Any, report: AWSO5MCPValidationReport):
         """Validate VPC Endpoints dependency analysis."""
         try:
             mcp_vpc_endpoints = self.ec2_client.describe_vpc_endpoints(
-                Filters=[{'Name': 'vpc-id', 'Values': [vpc_id]}]
-            )['VpcEndpoints']
-            
+                Filters=[{"Name": "vpc-id", "Values": [vpc_id]}]
+            )["VpcEndpoints"]
+
             # Count available endpoints
-            available_endpoints = [
-                ep for ep in mcp_vpc_endpoints
-                if ep['State'] == 'available'
-            ]
-            
+            available_endpoints = [ep for ep in mcp_vpc_endpoints if ep["State"] == "available"]
+
             mcp_count = len(available_endpoints)
-            runbooks_count = len([
-                dep for dep in dependency_result.dependencies
-                if dep.resource_type == 'VpcEndpoint'
-            ])
-            
+            runbooks_count = len([dep for dep in dependency_result.dependencies if dep.resource_type == "VpcEndpoint"])
+
             accuracy = self._calculate_accuracy(runbooks_count, mcp_count)
-            
+
             validation_result = MCPValidationResult(
                 validation_type="dependency",
                 check_name="VPC Endpoint Dependencies",
                 runbooks_value=runbooks_count,
                 mcp_value=mcp_count,
                 accuracy_percentage=accuracy,
-                validation_status="PASS" if accuracy >= 99.5 else "FAIL"
+                validation_status="PASS" if accuracy >= 99.5 else "FAIL",
             )
-            
+
             report.dependency_validation.append(validation_result)
-            
+
             if accuracy >= 99.5:
                 self.console.print(f"  ✅ VPC Endpoints: {accuracy:.2f}% accuracy")
             else:
                 self.console.print(f"  ❌ VPC Endpoints: {accuracy:.2f}% accuracy")
-                
+
         except ClientError as e:
             print_warning(f"VPC Endpoints validation failed: {e}")
-    
-    def _validate_load_balancers(
-        self, 
-        vpc_id: str, 
-        dependency_result: Any, 
-        report: AWSO5MCPValidationReport
-    ):
+
+    def _validate_load_balancers(self, vpc_id: str, dependency_result: Any, report: AWSO5MCPValidationReport):
         """Validate Load Balancer dependency analysis."""
         try:
-            mcp_load_balancers = self.elbv2_client.describe_load_balancers()['LoadBalancers']
-            
+            mcp_load_balancers = self.elbv2_client.describe_load_balancers()["LoadBalancers"]
+
             # Filter by VPC and active state
             vpc_load_balancers = [
-                lb for lb in mcp_load_balancers
-                if lb['VpcId'] == vpc_id and lb['State']['Code'] == 'active'
+                lb for lb in mcp_load_balancers if lb["VpcId"] == vpc_id and lb["State"]["Code"] == "active"
             ]
-            
+
             mcp_count = len(vpc_load_balancers)
-            runbooks_count = len([
-                dep for dep in dependency_result.dependencies
-                if dep.resource_type == 'LoadBalancer'
-            ])
-            
+            runbooks_count = len([dep for dep in dependency_result.dependencies if dep.resource_type == "LoadBalancer"])
+
             accuracy = self._calculate_accuracy(runbooks_count, mcp_count)
-            
+
             validation_result = MCPValidationResult(
                 validation_type="dependency",
                 check_name="Load Balancer Dependencies",
                 runbooks_value=runbooks_count,
                 mcp_value=mcp_count,
                 accuracy_percentage=accuracy,
-                validation_status="PASS" if accuracy >= 99.5 else "FAIL"
+                validation_status="PASS" if accuracy >= 99.5 else "FAIL",
             )
-            
+
             report.dependency_validation.append(validation_result)
-            
+
             if accuracy >= 99.5:
                 self.console.print(f"  ✅ Load Balancers: {accuracy:.2f}% accuracy")
             else:
                 self.console.print(f"  ❌ Load Balancers: {accuracy:.2f}% accuracy")
-                
+
         except ClientError as e:
             print_warning(f"Load Balancer validation failed: {e}")
-    
-    def _validate_architecture_analysis(
-        self, 
-        vpc_id: str, 
-        architecture_result: Any, 
-        report: AWSO5MCPValidationReport
-    ):
+
+    def _validate_architecture_analysis(self, vpc_id: str, architecture_result: Any, report: AWSO5MCPValidationReport):
         """Validate architecture analysis against compliance frameworks."""
-        
+
         # Validation 1: Default VPC Status
         try:
-            vpc_info = self.ec2_client.describe_vpcs(VpcIds=[vpc_id])['Vpcs'][0]
-            
-            mcp_is_default = vpc_info.get('IsDefault', False)
-            runbooks_is_default = getattr(architecture_result, 'is_default', False)
-            
+            vpc_info = self.ec2_client.describe_vpcs(VpcIds=[vpc_id])["Vpcs"][0]
+
+            mcp_is_default = vpc_info.get("IsDefault", False)
+            runbooks_is_default = getattr(architecture_result, "is_default", False)
+
             accuracy = 100.0 if mcp_is_default == runbooks_is_default else 0.0
-            
+
             validation_result = MCPValidationResult(
                 validation_type="architecture",
                 check_name="Default VPC Status",
                 runbooks_value=runbooks_is_default,
                 mcp_value=mcp_is_default,
                 accuracy_percentage=accuracy,
-                validation_status="PASS" if accuracy == 100.0 else "FAIL"
+                validation_status="PASS" if accuracy == 100.0 else "FAIL",
             )
-            
+
             report.architecture_validation.append(validation_result)
-            
+
             if accuracy == 100.0:
                 self.console.print(f"  ✅ Default VPC Status: {accuracy:.2f}% accuracy")
             else:
                 self.console.print(f"  ❌ Default VPC Status: {accuracy:.2f}% accuracy")
-                
+
         except ClientError as e:
             print_warning(f"Default VPC validation failed: {e}")
-        
+
         # Validation 2: Security Group Count
         self._validate_security_groups(vpc_id, architecture_result, report)
-        
+
         # Validation 3: CIDR Block Validation
         self._validate_cidr_blocks(vpc_id, architecture_result, report)
-    
-    def _validate_security_groups(
-        self, 
-        vpc_id: str, 
-        architecture_result: Any, 
-        report: AWSO5MCPValidationReport
-    ):
+
+    def _validate_security_groups(self, vpc_id: str, architecture_result: Any, report: AWSO5MCPValidationReport):
         """Validate security group analysis."""
         try:
             mcp_security_groups = self.ec2_client.describe_security_groups(
-                Filters=[{'Name': 'vpc-id', 'Values': [vpc_id]}]
-            )['SecurityGroups']
-            
+                Filters=[{"Name": "vpc-id", "Values": [vpc_id]}]
+            )["SecurityGroups"]
+
             mcp_count = len(mcp_security_groups)
-            
+
             # Extract count from architecture results (if available)
-            runbooks_count = getattr(architecture_result, 'security_group_count', mcp_count)
-            
+            runbooks_count = getattr(architecture_result, "security_group_count", mcp_count)
+
             accuracy = self._calculate_accuracy(runbooks_count, mcp_count)
-            
+
             validation_result = MCPValidationResult(
                 validation_type="architecture",
                 check_name="Security Group Count",
                 runbooks_value=runbooks_count,
                 mcp_value=mcp_count,
                 accuracy_percentage=accuracy,
-                validation_status="PASS" if accuracy >= 99.5 else "FAIL"
+                validation_status="PASS" if accuracy >= 99.5 else "FAIL",
             )
-            
+
             report.architecture_validation.append(validation_result)
-            
+
             if accuracy >= 99.5:
                 self.console.print(f"  ✅ Security Groups: {accuracy:.2f}% accuracy")
             else:
                 self.console.print(f"  ❌ Security Groups: {accuracy:.2f}% accuracy")
-                
+
         except ClientError as e:
             print_warning(f"Security Group validation failed: {e}")
-    
-    def _validate_cidr_blocks(
-        self, 
-        vpc_id: str, 
-        architecture_result: Any, 
-        report: AWSO5MCPValidationReport
-    ):
+
+    def _validate_cidr_blocks(self, vpc_id: str, architecture_result: Any, report: AWSO5MCPValidationReport):
         """Validate CIDR block analysis."""
         try:
-            vpc_info = self.ec2_client.describe_vpcs(VpcIds=[vpc_id])['Vpcs'][0]
-            
+            vpc_info = self.ec2_client.describe_vpcs(VpcIds=[vpc_id])["Vpcs"][0]
+
             mcp_cidrs = [
-                block['CidrBlock'] for block in vpc_info.get('CidrBlockAssociationSet', [])
-                if block['CidrBlockState']['State'] == 'associated'
+                block["CidrBlock"]
+                for block in vpc_info.get("CidrBlockAssociationSet", [])
+                if block["CidrBlockState"]["State"] == "associated"
             ]
-            
-            runbooks_cidrs = getattr(architecture_result, 'cidr_blocks', mcp_cidrs)
-            
+
+            runbooks_cidrs = getattr(architecture_result, "cidr_blocks", mcp_cidrs)
+
             # Compare CIDR sets
             mcp_cidr_set = set(mcp_cidrs)
             runbooks_cidr_set = set(runbooks_cidrs)
-            
+
             if mcp_cidr_set == runbooks_cidr_set:
                 accuracy = 100.0
             else:
@@ -635,37 +570,32 @@ class AWSO5MCPValidator:
                 intersection = len(mcp_cidr_set & runbooks_cidr_set)
                 union = len(mcp_cidr_set | runbooks_cidr_set)
                 accuracy = (intersection / union * 100) if union > 0 else 0.0
-            
+
             validation_result = MCPValidationResult(
                 validation_type="architecture",
                 check_name="CIDR Block Configuration",
                 runbooks_value=list(runbooks_cidr_set),
                 mcp_value=list(mcp_cidr_set),
                 accuracy_percentage=accuracy,
-                validation_status="PASS" if accuracy >= 99.5 else "FAIL"
+                validation_status="PASS" if accuracy >= 99.5 else "FAIL",
             )
-            
+
             report.architecture_validation.append(validation_result)
-            
+
             if accuracy >= 99.5:
                 self.console.print(f"  ✅ CIDR Blocks: {accuracy:.2f}% accuracy")
             else:
                 self.console.print(f"  ❌ CIDR Blocks: {accuracy:.2f}% accuracy")
-                
+
         except ClientError as e:
             print_warning(f"CIDR Block validation failed: {e}")
-    
-    def _validate_cost_impact(
-        self, 
-        vpc_id: str, 
-        dependency_result: Any, 
-        report: AWSO5MCPValidationReport
-    ):
+
+    def _validate_cost_impact(self, vpc_id: str, dependency_result: Any, report: AWSO5MCPValidationReport):
         """Validate cost impact projections."""
-        
+
         # Basic cost validation - in production would integrate with Cost Explorer
-        estimated_monthly_savings = getattr(dependency_result, 'estimated_monthly_savings', 0.0)
-        
+        estimated_monthly_savings = getattr(dependency_result, "estimated_monthly_savings", 0.0)
+
         # For now, validate that cost estimation is reasonable (0-1000 range for VPC cleanup)
         if 0 <= estimated_monthly_savings <= 1000:
             accuracy = 100.0
@@ -673,7 +603,7 @@ class AWSO5MCPValidator:
         else:
             accuracy = 75.0  # Questionable but not failing
             status = "WARNING"
-        
+
         validation_result = MCPValidationResult(
             validation_type="cost",
             check_name="Cost Impact Estimation",
@@ -682,32 +612,27 @@ class AWSO5MCPValidator:
             accuracy_percentage=accuracy,
             validation_status=status,
             variance_details={
-                'validation_method': 'Range validation (0-1000 USD/month)',
-                'assessment': 'Within expected range for VPC cleanup'
-            }
+                "validation_method": "Range validation (0-1000 USD/month)",
+                "assessment": "Within expected range for VPC cleanup",
+            },
         )
-        
+
         report.cost_validation.append(validation_result)
-        
+
         if accuracy >= 99.5:
             self.console.print(f"  ✅ Cost Estimation: {accuracy:.2f}% accuracy")
         else:
             self.console.print(f"  ⚠️ Cost Estimation: {accuracy:.2f}% accuracy (Range validated)")
-    
-    def _validate_security_posture(
-        self, 
-        vpc_id: str, 
-        architecture_result: Any, 
-        report: AWSO5MCPValidationReport
-    ):
+
+    def _validate_security_posture(self, vpc_id: str, architecture_result: Any, report: AWSO5MCPValidationReport):
         """Validate security posture assessment."""
-        
+
         # Validation 1: Flow Logs Status
         self._validate_flow_logs_status(vpc_id, architecture_result, report)
-        
+
         # Validation 2: Compliance Status Consistency
-        compliance_score = getattr(architecture_result, 'overall_compliance_score', 0.0)
-        
+        compliance_score = getattr(architecture_result, "overall_compliance_score", 0.0)
+
         # Validate compliance score is within reasonable range
         if 0 <= compliance_score <= 100:
             accuracy = 100.0
@@ -715,89 +640,78 @@ class AWSO5MCPValidator:
         else:
             accuracy = 0.0
             status = "FAIL"
-        
+
         validation_result = MCPValidationResult(
             validation_type="security",
             check_name="Compliance Score Range",
             runbooks_value=compliance_score,
             mcp_value="Valid Range (0-100)",
             accuracy_percentage=accuracy,
-            validation_status=status
+            validation_status=status,
         )
-        
+
         report.security_validation.append(validation_result)
-        
+
         if accuracy >= 99.5:
             self.console.print(f"  ✅ Compliance Score: {accuracy:.2f}% accuracy")
         else:
             self.console.print(f"  ❌ Compliance Score: {accuracy:.2f}% accuracy")
-    
-    def _validate_flow_logs_status(
-        self, 
-        vpc_id: str, 
-        architecture_result: Any, 
-        report: AWSO5MCPValidationReport
-    ):
+
+    def _validate_flow_logs_status(self, vpc_id: str, architecture_result: Any, report: AWSO5MCPValidationReport):
         """Validate VPC Flow Logs status."""
         try:
             mcp_flow_logs = self.ec2_client.describe_flow_logs(
-                Filters=[
-                    {'Name': 'resource-id', 'Values': [vpc_id]},
-                    {'Name': 'resource-type', 'Values': ['VPC']}
-                ]
-            )['FlowLogs']
-            
-            active_flow_logs = [
-                fl for fl in mcp_flow_logs
-                if fl['FlowLogStatus'] == 'ACTIVE'
-            ]
-            
+                Filters=[{"Name": "resource-id", "Values": [vpc_id]}, {"Name": "resource-type", "Values": ["VPC"]}]
+            )["FlowLogs"]
+
+            active_flow_logs = [fl for fl in mcp_flow_logs if fl["FlowLogStatus"] == "ACTIVE"]
+
             mcp_has_flow_logs = len(active_flow_logs) > 0
-            
+
             # Extract from architecture results
             runbooks_has_flow_logs = True  # Default assumption
-            
+
             accuracy = 100.0 if mcp_has_flow_logs == runbooks_has_flow_logs else 95.0  # Minor variance acceptable
-            
+
             validation_result = MCPValidationResult(
                 validation_type="security",
                 check_name="VPC Flow Logs Status",
                 runbooks_value=runbooks_has_flow_logs,
                 mcp_value=mcp_has_flow_logs,
                 accuracy_percentage=accuracy,
-                validation_status="PASS" if accuracy >= 95.0 else "FAIL"
+                validation_status="PASS" if accuracy >= 95.0 else "FAIL",
             )
-            
+
             report.security_validation.append(validation_result)
-            
+
             if accuracy >= 99.5:
                 self.console.print(f"  ✅ Flow Logs Status: {accuracy:.2f}% accuracy")
             else:
                 self.console.print(f"  ⚠️ Flow Logs Status: {accuracy:.2f}% accuracy")
-                
+
         except ClientError as e:
             print_warning(f"Flow Logs validation failed: {e}")
-    
+
     def _calculate_accuracy(self, runbooks_value: Any, mcp_value: Any) -> float:
         """Calculate accuracy percentage between runbooks and MCP values with enterprise tolerance."""
-        
+
         if isinstance(runbooks_value, (int, float)) and isinstance(mcp_value, (int, float)):
             # Perfect match
             if runbooks_value == mcp_value:
                 return 100.0
-            
+
             # Both zero
             if mcp_value == 0 and runbooks_value == 0:
                 return 100.0
-            
+
             # One zero, other non-zero
             if mcp_value == 0 or runbooks_value == 0:
                 return 0.0
-            
+
             # Calculate percentage variance
             max_value = max(abs(runbooks_value), abs(mcp_value))
             variance_percent = abs(runbooks_value - mcp_value) / max_value * 100
-            
+
             # Apply enterprise tolerance (±5% acceptable)
             if variance_percent <= 5.0:
                 return 100.0
@@ -805,40 +719,40 @@ class AWSO5MCPValidator:
                 # Scale accuracy based on variance beyond tolerance
                 accuracy = max(0.0, 100.0 - (variance_percent - 5.0))
                 return min(100.0, accuracy)
-        
+
         elif runbooks_value == mcp_value:
             return 100.0
         else:
             return 0.0
-    
+
     def _calculate_validation_metrics(self, report: AWSO5MCPValidationReport):
         """Calculate overall validation metrics."""
-        
+
         all_validations = (
-            report.dependency_validation + 
-            report.architecture_validation + 
-            report.cost_validation + 
-            report.security_validation
+            report.dependency_validation
+            + report.architecture_validation
+            + report.cost_validation
+            + report.security_validation
         )
-        
+
         report.total_validations = len(all_validations)
         report.passed_validations = len([v for v in all_validations if v.validation_status == "PASS"])
         report.failed_validations = len([v for v in all_validations if v.validation_status == "FAIL"])
-        
+
         if report.total_validations > 0:
             # Weighted accuracy calculation
             total_weight = 0
             weighted_accuracy = 0
-            
+
             for validation in all_validations:
                 weight = self._get_validation_weight(validation.validation_type)
                 total_weight += weight
                 weighted_accuracy += validation.accuracy_percentage * weight
-            
+
             report.overall_accuracy = weighted_accuracy / total_weight if total_weight > 0 else 0
         else:
             report.overall_accuracy = 0
-        
+
         # Determine overall validation status
         if report.overall_accuracy >= 99.5:
             report.validation_status = "PASSED"
@@ -846,121 +760,123 @@ class AWSO5MCPValidator:
             report.validation_status = "WARNING"
         else:
             report.validation_status = "FAILED"
-        
+
         # Set compliance status
         report.compliance_status = {
-            'enterprise_accuracy_target': 'MET' if report.meets_enterprise_accuracy else 'NOT_MET',
-            'validation_completeness': 'COMPLETE' if report.total_validations >= 10 else 'PARTIAL',
-            'evidence_generation': 'READY'
+            "enterprise_accuracy_target": "MET" if report.meets_enterprise_accuracy else "NOT_MET",
+            "validation_completeness": "COMPLETE" if report.total_validations >= 10 else "PARTIAL",
+            "evidence_generation": "READY",
         }
-    
+
     def _get_validation_weight(self, validation_type: str) -> float:
         """Get weight for validation type in accuracy calculation."""
         weights = {
-            'dependency': 3.0,  # Highest weight - core functionality
-            'architecture': 2.5,  # High weight - compliance critical
-            'security': 2.0,  # Important for compliance
-            'cost': 1.5  # Lower weight - estimation vs exact
+            "dependency": 3.0,  # Highest weight - core functionality
+            "architecture": 2.5,  # High weight - compliance critical
+            "security": 2.0,  # Important for compliance
+            "cost": 1.5,  # Lower weight - estimation vs exact
         }
         return weights.get(validation_type, 1.0)
-    
+
     def _generate_validation_hash(self, report: AWSO5MCPValidationReport) -> str:
         """Generate SHA256 hash for validation report integrity."""
-        
+
         # Create deterministic content for hashing
         hash_content = {
-            'vpc_id': report.vpc_id,
-            'account_id': report.account_id,
-            'region': report.region,
-            'overall_accuracy': report.overall_accuracy,
-            'total_validations': report.total_validations,
-            'passed_validations': report.passed_validations,
-            'validation_status': report.validation_status,
-            'validation_timestamp': report.validation_timestamp
+            "vpc_id": report.vpc_id,
+            "account_id": report.account_id,
+            "region": report.region,
+            "overall_accuracy": report.overall_accuracy,
+            "total_validations": report.total_validations,
+            "passed_validations": report.passed_validations,
+            "validation_status": report.validation_status,
+            "validation_timestamp": report.validation_timestamp,
         }
-        
+
         content_json = json.dumps(hash_content, sort_keys=True)
         return hashlib.sha256(content_json.encode()).hexdigest()
-    
+
     def _generate_evidence_bundle(self, report: AWSO5MCPValidationReport, evidence_path: str):
         """Generate SHA256-verified evidence bundle."""
-        
+
         evidence_bundle = {
-            'metadata': {
-                'framework': 'AWSO-5 MCP Validation',
-                'version': '1.0.0',
-                'vpc_id': report.vpc_id,
-                'account_id': report.account_id,
-                'region': report.region,
-                'timestamp': datetime.utcnow().isoformat(),
-                'validator': 'qa-testing-specialist'
+            "metadata": {
+                "framework": "AWSO-5 MCP Validation",
+                "version": "1.0.0",
+                "vpc_id": report.vpc_id,
+                "account_id": report.account_id,
+                "region": report.region,
+                "timestamp": datetime.utcnow().isoformat(),
+                "validator": "qa-testing-specialist",
             },
-            'validation_summary': {
-                'overall_accuracy': report.overall_accuracy,
-                'validation_status': report.validation_status,
-                'total_validations': report.total_validations,
-                'passed_validations': report.passed_validations,
-                'failed_validations': report.failed_validations,
-                'meets_enterprise_standard': report.meets_enterprise_accuracy
+            "validation_summary": {
+                "overall_accuracy": report.overall_accuracy,
+                "validation_status": report.validation_status,
+                "total_validations": report.total_validations,
+                "passed_validations": report.passed_validations,
+                "failed_validations": report.failed_validations,
+                "meets_enterprise_standard": report.meets_enterprise_accuracy,
             },
-            'detailed_results': {
-                'dependency_validation': [v.__dict__ for v in report.dependency_validation],
-                'architecture_validation': [v.__dict__ for v in report.architecture_validation],
-                'cost_validation': [v.__dict__ for v in report.cost_validation],
-                'security_validation': [v.__dict__ for v in report.security_validation]
+            "detailed_results": {
+                "dependency_validation": [v.__dict__ for v in report.dependency_validation],
+                "architecture_validation": [v.__dict__ for v in report.architecture_validation],
+                "cost_validation": [v.__dict__ for v in report.cost_validation],
+                "security_validation": [v.__dict__ for v in report.security_validation],
+            },
+            "compliance_status": report.compliance_status,
+            "validation_hash": report.validation_hash,
+            "quality_gates": {
+                "enterprise_accuracy_met": report.meets_enterprise_accuracy,
+                "validation_completeness": report.total_validations >= 10,
+                "evidence_integrity": True,
             },
-            'compliance_status': report.compliance_status,
-            'validation_hash': report.validation_hash,
-            'quality_gates': {
-                'enterprise_accuracy_met': report.meets_enterprise_accuracy,
-                'validation_completeness': report.total_validations >= 10,
-                'evidence_integrity': True
-            }
         }
-        
+
         # Calculate evidence bundle hash
         bundle_content = json.dumps(evidence_bundle, sort_keys=True, default=str)
         evidence_hash = hashlib.sha256(bundle_content.encode()).hexdigest()
-        evidence_bundle['evidence_bundle_hash'] = evidence_hash
-        
+        evidence_bundle["evidence_bundle_hash"] = evidence_hash
+
         # Save evidence bundle
-        with open(evidence_path, 'w') as f:
+        with open(evidence_path, "w") as f:
             json.dump(evidence_bundle, f, indent=2, default=str)
-        
+
         self.console.print(f"  ✅ Evidence bundle saved: {evidence_path}")
         self.console.print(f"  ✅ Evidence hash: {evidence_hash[:16]}...")
-    
+
     def _display_validation_results(self, report: AWSO5MCPValidationReport):
         """Display comprehensive MCP validation results."""
-        
+
         # Overall Summary
         summary_table = create_table(title="AWSO-5 MCP Validation Summary")
         summary_table.add_column("Metric", style="cyan", no_wrap=True)
         summary_table.add_column("Result", style="green")
         summary_table.add_column("Status", style="yellow")
-        
-        summary_table.add_row("Overall Accuracy", f"{report.overall_accuracy:.2f}%", 
-                             "✅ MEETS STANDARD" if report.meets_enterprise_accuracy else "❌ BELOW STANDARD")
+
+        summary_table.add_row(
+            "Overall Accuracy",
+            f"{report.overall_accuracy:.2f}%",
+            "✅ MEETS STANDARD" if report.meets_enterprise_accuracy else "❌ BELOW STANDARD",
+        )
         summary_table.add_row("Validation Status", report.validation_status, "")
         summary_table.add_row("Total Validations", str(report.total_validations), "")
         summary_table.add_row("Passed Validations", str(report.passed_validations), "")
         summary_table.add_row("Failed Validations", str(report.failed_validations), "")
-        summary_table.add_row("Enterprise Standard", "≥99.5%", 
-                             "MET" if report.meets_enterprise_accuracy else "NOT MET")
+        summary_table.add_row("Enterprise Standard", "≥99.5%", "MET" if report.meets_enterprise_accuracy else "NOT MET")
         summary_table.add_row("Validation Duration", f"{report.validation_duration_seconds:.2f}s", "")
         summary_table.add_row("Evidence Hash", report.validation_hash[:16] + "...", "")
-        
+
         self.console.print("\n")
         self.console.print(summary_table)
-        
+
         # Detailed Results by Category
         categories = [
             ("Dependency Validation", report.dependency_validation),
             ("Architecture Validation", report.architecture_validation),
             ("Cost Validation", report.cost_validation),
-            ("Security Validation", report.security_validation)
+            ("Security Validation", report.security_validation),
         ]
-        
+
         for category_name, validations in categories:
             if validations:
                 category_table = create_table(title=category_name)
@@ -969,21 +885,27 @@ class AWSO5MCPValidator:
                 category_table.add_column("MCP Value", style="green")
                 category_table.add_column("Accuracy", style="yellow")
                 category_table.add_column("Status", style="red")
-                
+
                 for validation in validations:
-                    status_icon = "✅" if validation.validation_status == "PASS" else "❌" if validation.validation_status == "FAIL" else "⚠️"
-                    
+                    status_icon = (
+                        "✅"
+                        if validation.validation_status == "PASS"
+                        else "❌"
+                        if validation.validation_status == "FAIL"
+                        else "⚠️"
+                    )
+
                     category_table.add_row(
                         validation.check_name,
                         str(validation.runbooks_value),
                         str(validation.mcp_value),
                         f"{validation.accuracy_percentage:.2f}%",
-                        f"{status_icon} {validation.validation_status}"
+                        f"{status_icon} {validation.validation_status}",
                     )
-                
+
                 self.console.print("\n")
                 self.console.print(category_table)
-        
+
         # Final Status Panel
         if report.validation_status == "PASSED":
             status_text = "[green]✅ MCP VALIDATION PASSED[/green]"
@@ -994,7 +916,7 @@ class AWSO5MCPValidator:
         else:
             status_text = "[red]❌ MCP VALIDATION FAILED[/red]"
             details = "Critical validations failed, review and remediate"
-        
+
         final_text = f"""
 {status_text}
 
@@ -1004,21 +926,26 @@ class AWSO5MCPValidator:
 **Evidence Hash:** {report.validation_hash[:16]}...
 
 **Quality Gates:**
-• Enterprise Accuracy: {'✅ MET' if report.meets_enterprise_accuracy else '❌ NOT MET'}
-• Validation Completeness: {'✅ COMPLETE' if report.total_validations >= 10 else '⚠️ PARTIAL'}
+• Enterprise Accuracy: {"✅ MET" if report.meets_enterprise_accuracy else "❌ NOT MET"}
+• Validation Completeness: {"✅ COMPLETE" if report.total_validations >= 10 else "⚠️ PARTIAL"}
 • Evidence Integrity: ✅ VERIFIED
 
 **Next Steps:**
 {details}
         """
-        
+
         from rich.panel import Panel
+
         status_panel = Panel(
             final_text,
             title="🧪 MCP Validation Results",
-            border_style="green" if report.validation_status == "PASSED" else "yellow" if report.validation_status == "WARNING" else "red"
+            border_style="green"
+            if report.validation_status == "PASSED"
+            else "yellow"
+            if report.validation_status == "WARNING"
+            else "red",
         )
-        
+
         self.console.print("\n")
         self.console.print(status_panel)
 
@@ -1029,11 +956,11 @@ def validate_vpc_with_mcp(
     architecture_result: Any,
     profile: Optional[str] = None,
     region: str = "us-east-1",
-    evidence_bundle_path: Optional[str] = None
+    evidence_bundle_path: Optional[str] = None,
 ) -> AWSO5MCPValidationReport:
     """
     CLI wrapper for AWSO-5 MCP validation.
-    
+
     Args:
         vpc_id: AWS VPC identifier
         dependency_result: VPC dependency analysis results
@@ -1041,68 +968,58 @@ def validate_vpc_with_mcp(
         profile: AWS profile name
         region: AWS region
         evidence_bundle_path: Path to save evidence bundle
-        
+
     Returns:
         Comprehensive MCP validation report
     """
     session = boto3.Session(profile_name=profile) if profile else boto3.Session()
     validator = AWSO5MCPValidator(session=session, region=region)
-    
-    return validator.comprehensive_vpc_validation(
-        vpc_id, 
-        dependency_result, 
-        architecture_result,
-        evidence_bundle_path
-    )
+
+    return validator.comprehensive_vpc_validation(vpc_id, dependency_result, architecture_result, evidence_bundle_path)
 
 
 if __name__ == "__main__":
     import argparse
-    
+
     parser = argparse.ArgumentParser(description="AWSO-5 MCP Validation Framework")
     parser.add_argument("--vpc-id", required=True, help="VPC ID to validate")
     parser.add_argument("--profile", help="AWS profile name")
     parser.add_argument("--region", default="us-east-1", help="AWS region")
     parser.add_argument("--evidence-bundle", help="Path to save evidence bundle")
-    
+
     args = parser.parse_args()
-    
+
     # For standalone testing, create minimal dependency and architecture results
     from dataclasses import dataclass
-    
+
     @dataclass
     class MockDependencyResult:
         eni_count: int = 0
         dependencies: list = None
         estimated_monthly_savings: float = 50.0
-        
+
         def __post_init__(self):
             if self.dependencies is None:
                 self.dependencies = []
-    
-    @dataclass 
+
+    @dataclass
     class MockArchitectureResult:
         is_default: bool = False
         cidr_blocks: list = None
         overall_compliance_score: float = 85.0
-        
+
         def __post_init__(self):
             if self.cidr_blocks is None:
                 self.cidr_blocks = ["10.0.0.0/16"]
-    
+
     mock_dependency = MockDependencyResult()
     mock_architecture = MockArchitectureResult()
-    
+
     result = validate_vpc_with_mcp(
-        args.vpc_id,
-        mock_dependency, 
-        mock_architecture,
-        args.profile,
-        args.region,
-        args.evidence_bundle
+        args.vpc_id, mock_dependency, mock_architecture, args.profile, args.region, args.evidence_bundle
     )
-    
+
     if result.meets_enterprise_accuracy:
         print_success(f"✅ MCP validation PASSED with {result.overall_accuracy:.2f}% accuracy")
     else:
-        print_error(f"❌ MCP validation FAILED with {result.overall_accuracy:.2f}% accuracy")
+        print_error(f"❌ MCP validation FAILED with {result.overall_accuracy:.2f}% accuracy")