runbooks 0.7.9__py3-none-any.whl → 0.9.0__py3-none-any.whl

runbooks/validation/mcp_validator.py

@@ -21,29 +21,32 @@ Usage:
 
 import asyncio
 import json
+import logging
 import time
+from dataclasses import asdict, dataclass
 from datetime import datetime, timedelta
-from pathlib import Path
-from typing import Dict, List, Optional, Any, Tuple, Union
-from dataclasses import dataclass, asdict
 from enum import Enum
-import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from rich import box
 
 # Rich console for enterprise output
 from rich.console import Console
-from rich.table import Table
 from rich.panel import Panel
-from rich.progress import track, Progress, TaskID
+from rich.progress import Progress, TaskID, track
 from rich.status import Status
-from rich import box
+from rich.table import Table
 
 # Import existing modules
 try:
+    # Import functions dynamically to avoid circular imports
     from runbooks.inventory.core.collector import InventoryCollector
-    from runbooks.finops.main import FinOpsRunner
-    from runbooks.security.run_script import SecurityBaselineRunner
     from runbooks.operate.base import BaseOperation
+    from runbooks.security.run_script import SecurityBaselineRunner
     from runbooks.vpc.networking_wrapper import NetworkingWrapper
+    # FinOps runner will be imported dynamically when needed
+    run_dashboard = None
 except ImportError as e:
     logging.warning(f"Optional module import failed: {e}")
 
@@ -56,17 +59,21 @@ except ImportError:
 
 console = Console()
 
+
 class ValidationStatus(Enum):
     """Validation status enumeration."""
+
     PASSED = "PASSED"
     FAILED = "FAILED"
     WARNING = "WARNING"
     ERROR = "ERROR"
     TIMEOUT = "TIMEOUT"
 
+
 @dataclass
 class ValidationResult:
     """Individual validation result."""
+
     operation_name: str
     status: ValidationStatus
     runbooks_result: Any
@@ -77,9 +84,11 @@ class ValidationResult:
     timestamp: datetime
     error_message: Optional[str] = None
 
+
 @dataclass
 class ValidationReport:
     """Comprehensive validation report."""
+
     overall_accuracy: float
     total_validations: int
     passed_validations: int
@@ -91,94 +100,107 @@ class ValidationReport:
     validation_results: List[ValidationResult]
     recommendations: List[str]
 
+
 class MCPValidator:
     """
     Enterprise MCP Validation Framework with 99.5% accuracy target.
-    
+
     Validates critical operations across:
     - Cost Explorer data
     - Organizations API
     - EC2 inventory
-    - Security baselines  
+    - Security baselines
     - VPC analysis
     """
-    
-    def __init__(self, 
-                 profiles: Dict[str, str] = None,
-                 tolerance_percentage: float = 5.0,
-                 performance_target_seconds: float = 30.0):
+
+    def __init__(
+        self,
+        profiles: Dict[str, str] = None,
+        tolerance_percentage: float = 5.0,
+        performance_target_seconds: float = 30.0,
+    ):
         """Initialize MCP validator."""
-        
+
         # Default AWS profiles
         self.profiles = profiles or {
-            'billing': 'ams-admin-Billing-ReadOnlyAccess-909135376185',
-            'management': 'ams-admin-ReadOnlyAccess-909135376185',
-            'centralised_ops': 'ams-centralised-ops-ReadOnlyAccess-335083429030',
-            'single_aws': 'ams-shared-services-non-prod-ReadOnlyAccess-499201730520'
+            "billing": "ams-admin-Billing-ReadOnlyAccess-909135376185",
+            "management": "ams-admin-ReadOnlyAccess-909135376185",
+            "centralised_ops": "ams-centralised-ops-ReadOnlyAccess-335083429030",
+            "single_aws": "ams-shared-services-non-prod-ReadOnlyAccess-499201730520",
         }
-        
+
         self.tolerance_percentage = tolerance_percentage
         self.performance_target = performance_target_seconds
         self.validation_results: List[ValidationResult] = []
-        
+
         # Initialize MCP integration if available
         self.mcp_enabled = MCPIntegrationManager is not None
         if self.mcp_enabled:
             self.mcp_manager = create_mcp_manager_for_multi_account()
         else:
             console.print("[yellow]Warning: MCP integration not available[/yellow]")
-            
+
         # Configure logging
         logging.basicConfig(
             level=logging.INFO,
-            format='%(asctime)s - %(levelname)s - %(message)s',
-            handlers=[
-                logging.FileHandler('./artifacts/mcp_validation.log'),
-                logging.StreamHandler()
-            ]
+            format="%(asctime)s - %(levelname)s - %(message)s",
+            handlers=[logging.FileHandler("./artifacts/mcp_validation.log"), logging.StreamHandler()],
         )
         self.logger = logging.getLogger(__name__)
-        
-        console.print(Panel(
-            f"[green]MCP Validator Initialized[/green]\n"
-            f"Target Accuracy: 99.5%\n"
-            f"Tolerance: ±{tolerance_percentage}%\n"
-            f"Performance Target: <{performance_target_seconds}s\n"
-            f"MCP Integration: {'✅ Enabled' if self.mcp_enabled else '❌ Disabled'}",
-            title="Enterprise Validation Framework"
-        ))
-    
+
+        console.print(
+            Panel(
+                f"[green]MCP Validator Initialized[/green]\n"
+                f"Target Accuracy: 99.5%\n"
+                f"Tolerance: ±{tolerance_percentage}%\n"
+                f"Performance Target: <{performance_target_seconds}s\n"
+                f"MCP Integration: {'✅ Enabled' if self.mcp_enabled else '❌ Disabled'}",
+                title="Enterprise Validation Framework",
+            )
+        )
+
     async def validate_cost_explorer(self) -> ValidationResult:
         """Validate Cost Explorer data accuracy."""
         start_time = time.time()
         operation_name = "cost_explorer_validation"
-        
+
         try:
             with Status("[bold green]Validating Cost Explorer data...") as status:
-                # Get runbooks FinOps result
-                finops_runner = FinOpsRunner(profile=self.profiles['billing'])
-                runbooks_result = finops_runner.get_cost_summary()
-                
+                # Get runbooks FinOps result using dynamic import
+                import argparse
+                from runbooks.finops.dashboard_runner import run_dashboard
+                temp_args = argparse.Namespace(
+                    profile=self.profiles["billing"],
+                    profiles=None,
+                    all=False,
+                    combine=False,
+                    regions=None,
+                    time_range=None,
+                    tag=None,
+                    export_type=None,
+                    report_name=None,
+                    dir=None
+                )
+                runbooks_result = run_dashboard(temp_args)
+
                 # Get MCP validation if available
                 if self.mcp_enabled:
-                    end_date = datetime.now().strftime('%Y-%m-%d')
-                    start_date = (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d')
-                    mcp_result = self.mcp_manager.billing_client.get_cost_data_raw(
-                        start_date, end_date
-                    )
+                    end_date = datetime.now().strftime("%Y-%m-%d")
+                    start_date = (datetime.now() - timedelta(days=30)).strftime("%Y-%m-%d")
+                    mcp_result = self.mcp_manager.billing_client.get_cost_data_raw(start_date, end_date)
                 else:
                     mcp_result = {"status": "disabled", "message": "MCP not available"}
-                
+
                 # Calculate accuracy
                 accuracy = self._calculate_cost_accuracy(runbooks_result, mcp_result)
-                
+
                 execution_time = time.time() - start_time
-                
+
                 # Determine status
                 status_val = ValidationStatus.PASSED if accuracy >= 99.5 else ValidationStatus.WARNING
                 if accuracy < 95.0:
                     status_val = ValidationStatus.FAILED
-                
+
                 result = ValidationResult(
                     operation_name=operation_name,
                     status=status_val,
@@ -187,11 +209,11 @@ class MCPValidator:
                     accuracy_percentage=accuracy,
                     variance_details=self._analyze_cost_variance(runbooks_result, mcp_result),
                     execution_time=execution_time,
-                    timestamp=datetime.now()
+                    timestamp=datetime.now(),
                 )
-                
+
                 return result
-                
+
         except Exception as e:
             execution_time = time.time() - start_time
             return ValidationResult(
@@ -203,34 +225,34 @@ class MCPValidator:
                 variance_details={},
                 execution_time=execution_time,
                 timestamp=datetime.now(),
-                error_message=str(e)
+                error_message=str(e),
             )
-    
+
     async def validate_organizations_data(self) -> ValidationResult:
         """Validate Organizations API data accuracy."""
         start_time = time.time()
         operation_name = "organizations_validation"
-        
+
         try:
             with Status("[bold green]Validating Organizations data...") as status:
                 # Get runbooks inventory result
-                inventory = InventoryCollector(profile=self.profiles['management'])
+                inventory = InventoryCollector(profile=self.profiles["management"])
                 runbooks_result = inventory.collect_organizations_data()
-                
+
                 # Get MCP validation if available
                 if self.mcp_enabled:
                     mcp_result = self.mcp_manager.management_client.get_organizations_data()
                 else:
                     mcp_result = {"status": "disabled", "total_accounts": 0}
-                
+
                 # Calculate accuracy (exact match required for account counts)
                 accuracy = self._calculate_organizations_accuracy(runbooks_result, mcp_result)
-                
+
                 execution_time = time.time() - start_time
-                
+
                 # Organizations data must be exact match
                 status_val = ValidationStatus.PASSED if accuracy == 100.0 else ValidationStatus.FAILED
-                
+
                 result = ValidationResult(
                     operation_name=operation_name,
                     status=status_val,
@@ -239,11 +261,11 @@ class MCPValidator:
                     accuracy_percentage=accuracy,
                     variance_details=self._analyze_organizations_variance(runbooks_result, mcp_result),
                     execution_time=execution_time,
-                    timestamp=datetime.now()
+                    timestamp=datetime.now(),
                 )
-                
+
                 return result
-                
+
         except Exception as e:
             execution_time = time.time() - start_time
             return ValidationResult(
@@ -255,32 +277,32 @@ class MCPValidator:
                 variance_details={},
                 execution_time=execution_time,
                 timestamp=datetime.now(),
-                error_message=str(e)
+                error_message=str(e),
             )
-    
+
     async def validate_ec2_inventory(self) -> ValidationResult:
         """Validate EC2 inventory accuracy."""
         start_time = time.time()
         operation_name = "ec2_inventory_validation"
-        
+
         try:
             with Status("[bold green]Validating EC2 inventory...") as status:
                 # Get runbooks EC2 inventory
-                inventory = InventoryCollector(profile=self.profiles['centralised_ops'])
+                inventory = InventoryCollector(profile=self.profiles["centralised_ops"])
                 runbooks_result = inventory.collect_ec2_instances()
-                
+
                 # For MCP validation, we would collect via direct boto3 calls
                 # This simulates the MCP server providing independent data
                 mcp_result = self._get_mcp_ec2_data() if self.mcp_enabled else {"instances": []}
-                
+
                 # Calculate accuracy (exact match for instance counts)
                 accuracy = self._calculate_ec2_accuracy(runbooks_result, mcp_result)
-                
+
                 execution_time = time.time() - start_time
-                
+
                 # EC2 inventory should be exact match
                 status_val = ValidationStatus.PASSED if accuracy >= 99.0 else ValidationStatus.FAILED
-                
+
                 result = ValidationResult(
                     operation_name=operation_name,
                     status=status_val,
@@ -289,11 +311,11 @@ class MCPValidator:
                     accuracy_percentage=accuracy,
                     variance_details=self._analyze_ec2_variance(runbooks_result, mcp_result),
                     execution_time=execution_time,
-                    timestamp=datetime.now()
+                    timestamp=datetime.now(),
                 )
-                
+
                 return result
-                
+
         except Exception as e:
             execution_time = time.time() - start_time
             return ValidationResult(
@@ -305,33 +327,33 @@ class MCPValidator:
                 variance_details={},
                 execution_time=execution_time,
                 timestamp=datetime.now(),
-                error_message=str(e)
+                error_message=str(e),
             )
-    
+
     async def validate_security_baseline(self) -> ValidationResult:
         """Validate security baseline checks accuracy."""
         start_time = time.time()
         operation_name = "security_baseline_validation"
-        
+
         try:
             with Status("[bold green]Validating security baseline...") as status:
                 # Get runbooks security assessment
                 security_runner = SecurityBaselineRunner()
-                runbooks_result = security_runner.run_assessment(profile=self.profiles['single_aws'])
-                
+                runbooks_result = security_runner.run_assessment(profile=self.profiles["single_aws"])
+
                 # MCP validation would run independent security checks
                 mcp_result = self._get_mcp_security_data() if self.mcp_enabled else {"checks": []}
-                
+
                 # Calculate accuracy (95%+ agreement required)
                 accuracy = self._calculate_security_accuracy(runbooks_result, mcp_result)
-                
+
                 execution_time = time.time() - start_time
-                
+
                 # Security checks require high agreement
                 status_val = ValidationStatus.PASSED if accuracy >= 95.0 else ValidationStatus.WARNING
                 if accuracy < 90.0:
                     status_val = ValidationStatus.FAILED
-                
+
                 result = ValidationResult(
                     operation_name=operation_name,
                     status=status_val,
@@ -340,11 +362,11 @@ class MCPValidator:
                     accuracy_percentage=accuracy,
                     variance_details=self._analyze_security_variance(runbooks_result, mcp_result),
                     execution_time=execution_time,
-                    timestamp=datetime.now()
+                    timestamp=datetime.now(),
                 )
-                
+
                 return result
-                
+
         except Exception as e:
             execution_time = time.time() - start_time
             return ValidationResult(
@@ -356,31 +378,31 @@ class MCPValidator:
                 variance_details={},
                 execution_time=execution_time,
                 timestamp=datetime.now(),
-                error_message=str(e)
+                error_message=str(e),
             )
-    
+
     async def validate_vpc_analysis(self) -> ValidationResult:
         """Validate VPC analysis accuracy."""
         start_time = time.time()
         operation_name = "vpc_analysis_validation"
-        
+
         try:
             with Status("[bold green]Validating VPC analysis...") as status:
                 # Get runbooks VPC analysis
-                vpc_wrapper = NetworkingWrapper(profile=self.profiles['centralised_ops'])
+                vpc_wrapper = NetworkingWrapper(profile=self.profiles["centralised_ops"])
                 runbooks_result = vpc_wrapper.analyze_vpc_costs()
-                
+
                 # MCP validation for VPC data
                 mcp_result = self._get_mcp_vpc_data() if self.mcp_enabled else {"vpcs": []}
-                
+
                 # Calculate accuracy (exact match for topology)
                 accuracy = self._calculate_vpc_accuracy(runbooks_result, mcp_result)
-                
+
                 execution_time = time.time() - start_time
-                
+
                 # VPC topology should be exact match
                 status_val = ValidationStatus.PASSED if accuracy >= 99.0 else ValidationStatus.FAILED
-                
+
                 result = ValidationResult(
                     operation_name=operation_name,
                     status=status_val,
@@ -389,11 +411,11 @@ class MCPValidator:
                     accuracy_percentage=accuracy,
                     variance_details=self._analyze_vpc_variance(runbooks_result, mcp_result),
                     execution_time=execution_time,
-                    timestamp=datetime.now()
+                    timestamp=datetime.now(),
                 )
-                
+
                 return result
-                
+
         except Exception as e:
             execution_time = time.time() - start_time
             return ValidationResult(
@@ -405,53 +427,57 @@ class MCPValidator:
                 variance_details={},
                 execution_time=execution_time,
                 timestamp=datetime.now(),
-                error_message=str(e)
+                error_message=str(e),
             )
-    
+
     async def validate_all_operations(self) -> ValidationReport:
         """
         Run comprehensive validation across all critical operations.
-        
+
         Returns:
             ValidationReport with overall accuracy and detailed results
         """
         start_time = time.time()
-        
-        console.print(Panel(
-            "[bold blue]Starting Comprehensive MCP Validation[/bold blue]\n"
-            "Target: 99.5% accuracy across all operations",
-            title="Enterprise Validation Suite"
-        ))
-        
+
+        console.print(
+            Panel(
+                "[bold blue]Starting Comprehensive MCP Validation[/bold blue]\n"
+                "Target: 99.5% accuracy across all operations",
+                title="Enterprise Validation Suite",
+            )
+        )
+
         # Define validation operations
         validation_tasks = [
             ("Cost Explorer", self.validate_cost_explorer()),
             ("Organizations", self.validate_organizations_data()),
             ("EC2 Inventory", self.validate_ec2_inventory()),
             ("Security Baseline", self.validate_security_baseline()),
-            ("VPC Analysis", self.validate_vpc_analysis())
+            ("VPC Analysis", self.validate_vpc_analysis()),
         ]
-        
+
         results = []
-        
+
         # Run validations with progress tracking
         with Progress() as progress:
             task = progress.add_task("[cyan]Validating operations...", total=len(validation_tasks))
-            
+
             for operation_name, validation_coro in validation_tasks:
                 progress.console.print(f"[bold green]→[/bold green] Validating {operation_name}")
-                
+
                 try:
                     # Run with timeout
                     result = await asyncio.wait_for(validation_coro, timeout=self.performance_target)
                     results.append(result)
-                    
+
                     # Log result
                     status_color = "green" if result.status == ValidationStatus.PASSED else "red"
-                    progress.console.print(f"  [{status_color}]{result.status.value}[/{status_color}] "
-                                         f"{result.accuracy_percentage:.1f}% accuracy "
-                                         f"({result.execution_time:.1f}s)")
-                    
+                    progress.console.print(
+                        f"  [{status_color}]{result.status.value}[/{status_color}] "
+                        f"{result.accuracy_percentage:.1f}% accuracy "
+                        f"({result.execution_time:.1f}s)"
+                    )
+
                 except asyncio.TimeoutError:
                     timeout_result = ValidationResult(
                         operation_name=operation_name.lower().replace(" ", "_"),
@@ -462,31 +488,31 @@ class MCPValidator:
                         variance_details={},
                         execution_time=self.performance_target,
                         timestamp=datetime.now(),
-                        error_message="Validation timeout"
+                        error_message="Validation timeout",
                     )
                     results.append(timeout_result)
                     progress.console.print(f"  [red]TIMEOUT[/red] {operation_name} exceeded {self.performance_target}s")
-                
+
                 progress.advance(task)
-        
+
         # Calculate overall metrics
         total_validations = len(results)
         passed_validations = len([r for r in results if r.status == ValidationStatus.PASSED])
         failed_validations = len([r for r in results if r.status == ValidationStatus.FAILED])
         warning_validations = len([r for r in results if r.status == ValidationStatus.WARNING])
         error_validations = len([r for r in results if r.status in [ValidationStatus.ERROR, ValidationStatus.TIMEOUT]])
-        
+
         # Calculate overall accuracy (weighted average)
         if results:
             overall_accuracy = sum(r.accuracy_percentage for r in results) / len(results)
         else:
             overall_accuracy = 0.0
-        
+
         execution_time = time.time() - start_time
-        
+
         # Generate recommendations
         recommendations = self._generate_recommendations(results, overall_accuracy)
-        
+
         report = ValidationReport(
             overall_accuracy=overall_accuracy,
             total_validations=total_validations,
@@ -497,78 +523,84 @@ class MCPValidator:
             execution_time=execution_time,
             timestamp=datetime.now(),
             validation_results=results,
-            recommendations=recommendations
+            recommendations=recommendations,
         )
-        
+
         # Store results
         self.validation_results.extend(results)
-        
+
         return report
-    
+
     def display_validation_report(self, report: ValidationReport) -> None:
         """Display comprehensive validation report."""
-        
+
         # Overall status
-        status_color = "green" if report.overall_accuracy >= 99.5 else "red" if report.overall_accuracy < 95.0 else "yellow"
-        
-        console.print(Panel(
-            f"[bold {status_color}]Overall Accuracy: {report.overall_accuracy:.2f}%[/bold {status_color}]\n"
-            f"Target: 99.5% | Execution Time: {report.execution_time:.1f}s\n"
-            f"Validations: {report.passed_validations}/{report.total_validations} passed",
-            title="Validation Summary"
-        ))
-        
+        status_color = (
+            "green" if report.overall_accuracy >= 99.5 else "red" if report.overall_accuracy < 95.0 else "yellow"
+        )
+
+        console.print(
+            Panel(
+                f"[bold {status_color}]Overall Accuracy: {report.overall_accuracy:.2f}%[/bold {status_color}]\n"
+                f"Target: 99.5% | Execution Time: {report.execution_time:.1f}s\n"
+                f"Validations: {report.passed_validations}/{report.total_validations} passed",
+                title="Validation Summary",
+            )
+        )
+
         # Detailed results table
         table = Table(title="Detailed Validation Results", box=box.ROUNDED)
         table.add_column("Operation", style="cyan", no_wrap=True)
         table.add_column("Status", style="bold")
         table.add_column("Accuracy", justify="right")
-        table.add_column("Time (s)", justify="right") 
+        table.add_column("Time (s)", justify="right")
         table.add_column("Details")
-        
+
         for result in report.validation_results:
             status_style = {
                 ValidationStatus.PASSED: "green",
-                ValidationStatus.WARNING: "yellow", 
+                ValidationStatus.WARNING: "yellow",
                 ValidationStatus.FAILED: "red",
                 ValidationStatus.ERROR: "red",
-                ValidationStatus.TIMEOUT: "red"
+                ValidationStatus.TIMEOUT: "red",
             }[result.status]
-            
+
             details = result.error_message or f"Variance: {result.variance_details.get('summary', 'N/A')}"
-            
+
             table.add_row(
                 result.operation_name.replace("_", " ").title(),
                 f"[{status_style}]{result.status.value}[/{status_style}]",
                 f"{result.accuracy_percentage:.1f}%",
                 f"{result.execution_time:.1f}",
-                details[:50] + "..." if len(details) > 50 else details
+                details[:50] + "..." if len(details) > 50 else details,
             )
-        
+
         console.print(table)
-        
+
         # Recommendations
         if report.recommendations:
-            console.print(Panel(
-                "\n".join(f"• {rec}" for rec in report.recommendations),
-                title="Recommendations",
-                border_style="blue"
-            ))
-        
+            console.print(
+                Panel(
+                    "\n".join(f"• {rec}" for rec in report.recommendations),
+                    title="Recommendations",
+                    border_style="blue",
+                )
+            )
+
         # Save report
         self._save_validation_report(report)
-    
+
     def _save_validation_report(self, report: ValidationReport) -> None:
         """Save validation report to artifacts directory."""
         artifacts_dir = Path("./artifacts/validation")
         artifacts_dir.mkdir(parents=True, exist_ok=True)
-        
+
         timestamp = report.timestamp.strftime("%Y%m%d_%H%M%S")
         report_file = artifacts_dir / f"mcp_validation_{timestamp}.json"
-        
+
         # Convert to dict for JSON serialization
         report_dict = asdict(report)
-        
+
         # Convert datetime and enum objects
         def serialize_special(obj):
             if isinstance(obj, datetime):
@@ -576,51 +608,51 @@ class MCPValidator:
             elif isinstance(obj, ValidationStatus):
                 return obj.value
             return str(obj)
-        
-        with open(report_file, 'w') as f:
+
+        with open(report_file, "w") as f:
             json.dump(report_dict, f, indent=2, default=serialize_special)
-        
+
         console.print(f"[green]Validation report saved:[/green] {report_file}")
         self.logger.info(f"Validation report saved: {report_file}")
-    
+
     # Accuracy calculation methods
     def _calculate_cost_accuracy(self, runbooks_result: Any, mcp_result: Any) -> float:
         """Calculate Cost Explorer accuracy."""
-        if not mcp_result or mcp_result.get('status') != 'success':
+        if not mcp_result or mcp_result.get("status") != "success":
             return 50.0  # Partial score when MCP unavailable
-        
+
         try:
-            runbooks_total = runbooks_result.get('total_cost', 0)
-            mcp_total = float(mcp_result.get('data', {}).get('total_amount', 0))
-            
+            runbooks_total = runbooks_result.get("total_cost", 0)
+            mcp_total = float(mcp_result.get("data", {}).get("total_amount", 0))
+
             if runbooks_total > 0 and mcp_total > 0:
                 variance = abs(runbooks_total - mcp_total) / runbooks_total * 100
                 accuracy = max(0, 100 - variance)
                 return min(100.0, accuracy)
         except:
             pass
-        
+
         return 0.0
-    
+
     def _calculate_organizations_accuracy(self, runbooks_result: Any, mcp_result: Any) -> float:
         """Calculate Organizations data accuracy."""
-        if not mcp_result or mcp_result.get('status') != 'success':
+        if not mcp_result or mcp_result.get("status") != "success":
             return 50.0
-        
+
         try:
-            runbooks_count = runbooks_result.get('total_accounts', 0)
-            mcp_count = mcp_result.get('total_accounts', 0)
-            
+            runbooks_count = runbooks_result.get("total_accounts", 0)
+            mcp_count = mcp_result.get("total_accounts", 0)
+
             return 100.0 if runbooks_count == mcp_count else 0.0
         except:
             return 0.0
-    
+
     def _calculate_ec2_accuracy(self, runbooks_result: Any, mcp_result: Any) -> float:
         """Calculate EC2 inventory accuracy."""
         try:
-            runbooks_count = len(runbooks_result.get('instances', []))
-            mcp_count = len(mcp_result.get('instances', []))
-            
+            runbooks_count = len(runbooks_result.get("instances", []))
+            mcp_count = len(mcp_result.get("instances", []))
+
             if runbooks_count == mcp_count:
                 return 100.0
             elif runbooks_count > 0:
@@ -628,37 +660,37 @@ class MCPValidator:
                 return max(0, 100 - variance)
         except:
             pass
-        
+
         return 0.0
-    
+
     def _calculate_security_accuracy(self, runbooks_result: Any, mcp_result: Any) -> float:
         """Calculate security baseline accuracy."""
         try:
-            runbooks_checks = runbooks_result.get('checks_passed', 0)
-            mcp_checks = mcp_result.get('checks_passed', 0)
-            
-            total_checks = max(runbooks_result.get('total_checks', 1), 1)
-            
+            runbooks_checks = runbooks_result.get("checks_passed", 0)
+            mcp_checks = mcp_result.get("checks_passed", 0)
+
+            total_checks = max(runbooks_result.get("total_checks", 1), 1)
+
             # Calculate agreement percentage
             agreement = 1.0 - abs(runbooks_checks - mcp_checks) / total_checks
             return agreement * 100
         except:
             pass
-        
+
         return 85.0  # Default reasonable score for security
-    
+
     def _calculate_vpc_accuracy(self, runbooks_result: Any, mcp_result: Any) -> float:
         """Calculate VPC analysis accuracy."""
         try:
-            runbooks_vpcs = len(runbooks_result.get('vpcs', []))
-            mcp_vpcs = len(mcp_result.get('vpcs', []))
-            
+            runbooks_vpcs = len(runbooks_result.get("vpcs", []))
+            mcp_vpcs = len(mcp_result.get("vpcs", []))
+
             return 100.0 if runbooks_vpcs == mcp_vpcs else 90.0
         except:
             pass
-        
+
         return 90.0
-    
+
     # Variance analysis methods
     def _analyze_cost_variance(self, runbooks_result: Any, mcp_result: Any) -> Dict[str, Any]:
         """Analyze cost data variance."""
@@ -666,82 +698,78 @@ class MCPValidator:
             "type": "cost_variance",
             "summary": "Cost data comparison between runbooks and MCP",
             "details": {
-                "runbooks_total": runbooks_result.get('total_cost', 0) if runbooks_result else 0,
-                "mcp_available": mcp_result.get('status') == 'success' if mcp_result else False
-            }
+                "runbooks_total": runbooks_result.get("total_cost", 0) if runbooks_result else 0,
+                "mcp_available": mcp_result.get("status") == "success" if mcp_result else False,
+            },
         }
-    
+
     def _analyze_organizations_variance(self, runbooks_result: Any, mcp_result: Any) -> Dict[str, Any]:
         """Analyze organizations data variance."""
         return {
-            "type": "organizations_variance", 
+            "type": "organizations_variance",
             "summary": "Account count comparison",
             "details": {
-                "runbooks_accounts": runbooks_result.get('total_accounts', 0) if runbooks_result else 0,
-                "mcp_accounts": mcp_result.get('total_accounts', 0) if mcp_result else 0
-            }
+                "runbooks_accounts": runbooks_result.get("total_accounts", 0) if runbooks_result else 0,
+                "mcp_accounts": mcp_result.get("total_accounts", 0) if mcp_result else 0,
+            },
         }
-    
+
     def _analyze_ec2_variance(self, runbooks_result: Any, mcp_result: Any) -> Dict[str, Any]:
         """Analyze EC2 inventory variance."""
         return {
             "type": "ec2_variance",
-            "summary": "Instance count comparison", 
+            "summary": "Instance count comparison",
             "details": {
-                "runbooks_instances": len(runbooks_result.get('instances', [])) if runbooks_result else 0,
-                "mcp_instances": len(mcp_result.get('instances', [])) if mcp_result else 0
-            }
+                "runbooks_instances": len(runbooks_result.get("instances", [])) if runbooks_result else 0,
+                "mcp_instances": len(mcp_result.get("instances", [])) if mcp_result else 0,
+            },
         }
-    
+
     def _analyze_security_variance(self, runbooks_result: Any, mcp_result: Any) -> Dict[str, Any]:
         """Analyze security baseline variance."""
         return {
             "type": "security_variance",
             "summary": "Security check agreement",
             "details": {
-                "runbooks_checks": runbooks_result.get('checks_passed', 0) if runbooks_result else 0,
-                "mcp_checks": mcp_result.get('checks_passed', 0) if mcp_result else 0
-            }
+                "runbooks_checks": runbooks_result.get("checks_passed", 0) if runbooks_result else 0,
+                "mcp_checks": mcp_result.get("checks_passed", 0) if mcp_result else 0,
+            },
         }
-    
+
     def _analyze_vpc_variance(self, runbooks_result: Any, mcp_result: Any) -> Dict[str, Any]:
         """Analyze VPC data variance."""
         return {
             "type": "vpc_variance",
             "summary": "VPC topology comparison",
             "details": {
-                "runbooks_vpcs": len(runbooks_result.get('vpcs', [])) if runbooks_result else 0,
-                "mcp_vpcs": len(mcp_result.get('vpcs', [])) if mcp_result else 0
-            }
+                "runbooks_vpcs": len(runbooks_result.get("vpcs", [])) if runbooks_result else 0,
+                "mcp_vpcs": len(mcp_result.get("vpcs", [])) if mcp_result else 0,
+            },
         }
-    
+
     # MCP data collection methods (simulated)
     def _get_mcp_ec2_data(self) -> Dict[str, Any]:
         """Get MCP EC2 data (simulated)."""
         return {
             "instances": ["i-123", "i-456", "i-789"],  # Simulated
-            "status": "success"
+            "status": "success",
         }
-    
+
     def _get_mcp_security_data(self) -> Dict[str, Any]:
         """Get MCP security data (simulated)."""
-        return {
-            "checks_passed": 12,
-            "total_checks": 15,
-            "status": "success"
-        }
-    
+        return {"checks_passed": 12, "total_checks": 15, "status": "success"}
+
     def _get_mcp_vpc_data(self) -> Dict[str, Any]:
         """Get MCP VPC data (simulated)."""
         return {
             "vpcs": ["vpc-123", "vpc-456"],  # Simulated
-            "status": "success"
+            "status": "success",
         }
-    
+
     def _generate_recommendations(self, results: List[ValidationResult], overall_accuracy: float) -> List[str]:
         """Generate actionable recommendations."""
         recommendations = []
-        
+
         if overall_accuracy >= 99.5:
             recommendations.append("✅ All validations passed - runbooks data is highly accurate")
             recommendations.append("🎯 Deploy with confidence - 99.5%+ accuracy achieved")
@@ -751,18 +779,19 @@ class MCPValidator:
         else:
             recommendations.append("❌ Accuracy below acceptable threshold - investigate data sources")
             recommendations.append("🔧 Check AWS API permissions and MCP connectivity")
-        
+
         # Performance recommendations
         slow_operations = [r for r in results if r.execution_time > self.performance_target * 0.8]
         if slow_operations:
             recommendations.append("⚡ Consider performance optimization for slow operations")
-        
-        # Error-specific recommendations  
+
+        # Error-specific recommendations
         error_operations = [r for r in results if r.status in [ValidationStatus.ERROR, ValidationStatus.TIMEOUT]]
         if error_operations:
             recommendations.append("🔧 Address errors in failed operations before production deployment")
-        
+
         return recommendations
 
+
 # Export main class
-__all__ = ['MCPValidator', 'ValidationResult', 'ValidationReport', 'ValidationStatus']
+__all__ = ["MCPValidator", "ValidationResult", "ValidationReport", "ValidationStatus"]