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

runbooks/cloudops/mcp_cost_validation.py

@@ -8,7 +8,7 @@ CLI interfaces for comprehensive DoD validation.
 
 Key Capabilities:
 - Real-time Cost Explorer MCP validation
-- Cross-validation between notebook estimates and AWS APIs  
+- Cross-validation between notebook estimates and AWS APIs
 - Technical CLI interfaces for automation testing
 - Comprehensive DoD evidence generation
 - Performance benchmarking with >99.9% reliability targets
@@ -39,22 +39,36 @@ import boto3
 from botocore.exceptions import ClientError
 
 from runbooks.common.rich_utils import (
-    console, print_header, print_success, print_error, print_warning, print_info,
-    create_table, create_progress_bar, format_cost, create_panel, STATUS_INDICATORS
+    console,
+    print_header,
+    print_success,
+    print_error,
+    print_warning,
+    print_info,
+    create_table,
+    create_progress_bar,
+    format_cost,
+    create_panel,
+    STATUS_INDICATORS,
 )
 
 # Import MCP integration framework
-from notebooks.mcp_integration import (
-    MCPIntegrationManager, CrossValidationEngine, MCPAWSClient,
-    create_mcp_manager_for_single_account, create_mcp_manager_for_multi_account
+from runbooks.mcp import (
+    MCPIntegrationManager,
+    CrossValidationEngine,
+    MCPAWSClient,
+    create_mcp_manager_for_single_account,
+    create_mcp_manager_for_multi_account,
 )
 
 from .models import BusinessScenario, ExecutionMode, RiskLevel, CostOptimizationResult
 from .cost_optimizer import CostOptimizer
 
+
 @dataclass
 class MCPValidationResult:
     """Result structure for MCP validation operations."""
+
     scenario_name: str
     validation_timestamp: datetime
     mcp_enabled: bool
@@ -69,9 +83,11 @@ class MCPValidationResult:
     performance_metrics: Dict[str, float]
     evidence_files: Dict[str, str]
 
-@dataclass  
+
+@dataclass
 class TechnicalTestResult:
     """Technical test result for CLI validation."""
+
     test_name: str
     success: bool
     execution_time_ms: float
@@ -82,27 +98,28 @@ class TechnicalTestResult:
     performance_benchmark_met: bool
     evidence_generated: bool
 
+
 class MCPCostValidationEngine:
     """
     MCP-validated cost optimization engine for technical CLI and business notebook usage.
-    
+
     Provides comprehensive cost optimization validation with real AWS Cost Explorer data,
     cross-validation capabilities, and DoD-compliant evidence generation.
     """
-    
+
     def __init__(
         self,
         billing_profile: str,
         management_profile: str,
         tolerance_percent: float = 5.0,
-        performance_target_ms: float = 30000.0  # 30 second target
+        performance_target_ms: float = 30000.0,  # 30 second target
     ):
         """
         Initialize MCP cost validation engine.
-        
+
         Args:
             billing_profile: AWS profile with Cost Explorer access
-            management_profile: AWS profile with Organizations access  
+            management_profile: AWS profile with Organizations access
             tolerance_percent: Variance tolerance for cross-validation
             performance_target_ms: Performance target in milliseconds
         """
@@ -110,103 +127,94 @@ class MCPCostValidationEngine:
         self.management_profile = management_profile
         self.tolerance_percent = tolerance_percent
         self.performance_target_ms = performance_target_ms
-        
+
         # Initialize MCP integration manager
         self.mcp_manager = MCPIntegrationManager(
-            billing_profile=billing_profile,
-            management_profile=management_profile,
-            tolerance_percent=tolerance_percent
+            billing_profile=billing_profile, management_profile=management_profile, tolerance_percent=tolerance_percent
         )
-        
+
         # Performance tracking
         self.start_time = time.time()
         self.api_calls_made = 0
         self.cost_data_points = 0
-        
+
         # Evidence collection
         self.evidence_dir = Path("mcp-validation-evidence")
         self.evidence_dir.mkdir(parents=True, exist_ok=True)
-        
+
         print_header("MCP Cost Validation Engine", "1.0.0")
         print_info(f"🔍 Cross-validation tolerance: ±{tolerance_percent}%")
-        print_info(f"⚡ Performance target: <{performance_target_ms/1000:.1f}s")
+        print_info(f"⚡ Performance target: <{performance_target_ms / 1000:.1f}s")
         print_info(f"📊 Evidence collection: {self.evidence_dir}")
 
     async def validate_cost_optimization_scenario(
-        self,
-        scenario_name: str,
-        cost_optimizer_params: Dict[str, Any],
-        expected_savings_range: Tuple[float, float]
+        self, scenario_name: str, cost_optimizer_params: Dict[str, Any], expected_savings_range: Tuple[float, float]
     ) -> TechnicalTestResult:
         """
         Validate a complete cost optimization scenario with MCP cross-validation.
-        
+
         Args:
             scenario_name: Name of the cost optimization scenario
             cost_optimizer_params: Parameters for cost optimizer execution
             expected_savings_range: Expected savings range (min, max) for validation
-            
+
         Returns:
             TechnicalTestResult with comprehensive validation results
         """
         test_start_time = time.time()
         print_info(f"🧪 Testing scenario: {scenario_name}")
-        
+
         try:
             # Initialize cost optimizer
             cost_optimizer = CostOptimizer(
-                profile=cost_optimizer_params.get('profile', self.billing_profile),
+                profile=cost_optimizer_params.get("profile", self.billing_profile),
                 dry_run=True,  # Always safe mode for validation
-                execution_mode=ExecutionMode.VALIDATE_ONLY
+                execution_mode=ExecutionMode.VALIDATE_ONLY,
             )
-            
+
             # Execute cost optimization scenario
             if scenario_name.lower().startswith("nat_gateway"):
                 result = await cost_optimizer.optimize_nat_gateways(
-                    regions=cost_optimizer_params.get('regions'),
-                    idle_threshold_days=cost_optimizer_params.get('idle_threshold_days', 7),
-                    cost_threshold=cost_optimizer_params.get('cost_threshold', 0.0)
+                    regions=cost_optimizer_params.get("regions"),
+                    idle_threshold_days=cost_optimizer_params.get("idle_threshold_days", 7),
+                    cost_threshold=cost_optimizer_params.get("cost_threshold", 0.0),
                 )
             elif scenario_name.lower().startswith("ec2_idle"):
                 result = await cost_optimizer.optimize_idle_ec2_instances(
-                    regions=cost_optimizer_params.get('regions'),
-                    cpu_threshold=cost_optimizer_params.get('cpu_threshold', 5.0),
-                    duration_hours=cost_optimizer_params.get('duration_hours', 168),
-                    cost_threshold=cost_optimizer_params.get('cost_threshold', 10.0)
+                    regions=cost_optimizer_params.get("regions"),
+                    cpu_threshold=cost_optimizer_params.get("cpu_threshold", 5.0),
+                    duration_hours=cost_optimizer_params.get("duration_hours", 168),
+                    cost_threshold=cost_optimizer_params.get("cost_threshold", 10.0),
                 )
             elif scenario_name.lower().startswith("emergency_response"):
                 result = await cost_optimizer.emergency_cost_response(
-                    cost_spike_threshold=cost_optimizer_params.get('cost_spike_threshold', 25000.0),
-                    analysis_days=cost_optimizer_params.get('analysis_days', 7)
+                    cost_spike_threshold=cost_optimizer_params.get("cost_spike_threshold", 25000.0),
+                    analysis_days=cost_optimizer_params.get("analysis_days", 7),
                 )
             else:
                 raise ValueError(f"Unknown scenario: {scenario_name}")
-            
+
             # Extract cost optimization results
             notebook_total_cost = result.business_metrics.total_monthly_savings
             self.cost_data_points += len(result.resources_impacted)
-            
+
             # Validate with MCP Cost Explorer
             mcp_validation = await self._cross_validate_with_mcp(
                 scenario_name=scenario_name,
-                notebook_result={'cost_trends': {'total_monthly_spend': notebook_total_cost}},
-                cost_optimizer_result=result
+                notebook_result={"cost_trends": {"total_monthly_spend": notebook_total_cost}},
+                cost_optimizer_result=result,
             )
-            
+
             # Check if savings are within expected range
-            savings_in_range = (
-                expected_savings_range[0] <= notebook_total_cost <= expected_savings_range[1]
-            )
-            
+            savings_in_range = expected_savings_range[0] <= notebook_total_cost <= expected_savings_range[1]
+
             # Calculate performance metrics
             execution_time_ms = (time.time() - test_start_time) * 1000
             performance_met = execution_time_ms <= self.performance_target_ms
-            
+
             # Generate evidence
-            evidence_files = await self._generate_test_evidence(
-                scenario_name, result, mcp_validation
-            )
-            
+            evidence_files = await self._generate_test_evidence(scenario_name, result, mcp_validation)
+
             return TechnicalTestResult(
                 test_name=scenario_name,
                 success=result.success and savings_in_range and mcp_validation.variance_within_tolerance,
@@ -216,12 +224,12 @@ class MCPCostValidationEngine:
                 aws_api_calls=self.api_calls_made,
                 cost_data_points=self.cost_data_points,
                 performance_benchmark_met=performance_met,
-                evidence_generated=len(evidence_files) > 0
+                evidence_generated=len(evidence_files) > 0,
             )
-            
+
         except Exception as e:
             execution_time_ms = (time.time() - test_start_time) * 1000
-            
+
             return TechnicalTestResult(
                 test_name=scenario_name,
                 success=False,
@@ -231,56 +239,52 @@ class MCPCostValidationEngine:
                 aws_api_calls=self.api_calls_made,
                 cost_data_points=0,
                 performance_benchmark_met=execution_time_ms <= self.performance_target_ms,
-                evidence_generated=False
+                evidence_generated=False,
             )
 
     async def _cross_validate_with_mcp(
-        self,
-        scenario_name: str,
-        notebook_result: Dict[str, Any],
-        cost_optimizer_result: CostOptimizationResult
+        self, scenario_name: str, notebook_result: Dict[str, Any], cost_optimizer_result: CostOptimizationResult
     ) -> MCPValidationResult:
         """Cross-validate notebook results with MCP Cost Explorer data."""
         validation_start = time.time()
-        
+
         print_info("🔍 Cross-validating with MCP Cost Explorer...")
-        
+
         # Get MCP validation results
         validation_report = self.mcp_manager.validate_notebook_results(notebook_result)
-        
+
         # Extract validation metrics
         cost_validations = [
-            v for v in validation_report.get('validations', []) 
-            if v.get('validation_type') == 'cost_data_cross_check'
+            v for v in validation_report.get("validations", []) if v.get("validation_type") == "cost_data_cross_check"
         ]
-        
+
         if cost_validations:
             cost_validation = cost_validations[0]
-            variance_analysis = cost_validation.get('variance_analysis', {})
-            
-            notebook_total = variance_analysis.get('notebook_total', 0.0)
-            mcp_total = variance_analysis.get('mcp_total', 0.0) 
-            variance_pct = variance_analysis.get('variance_percent', 0.0)
+            variance_analysis = cost_validation.get("variance_analysis", {})
+
+            notebook_total = variance_analysis.get("notebook_total", 0.0)
+            mcp_total = variance_analysis.get("mcp_total", 0.0)
+            variance_pct = variance_analysis.get("variance_percent", 0.0)
             variance_within_tolerance = variance_pct <= self.tolerance_percent
-            
+
         else:
             # No MCP validation available
-            notebook_total = notebook_result.get('cost_trends', {}).get('total_monthly_spend', 0.0)
+            notebook_total = notebook_result.get("cost_trends", {}).get("total_monthly_spend", 0.0)
             mcp_total = 0.0
             variance_pct = 0.0
             variance_within_tolerance = False
-        
+
         # Generate recommendations
-        recommendations = validation_report.get('recommendations', [])
+        recommendations = validation_report.get("recommendations", [])
         if not recommendations:
             if variance_within_tolerance:
                 recommendations = ["✅ Data validated - proceed with confidence"]
             else:
                 recommendations = ["⚠️ Variance detected - investigate data sources"]
-        
+
         # Performance metrics
         validation_time = time.time() - validation_start
-        
+
         return MCPValidationResult(
             scenario_name=scenario_name,
             validation_timestamp=datetime.now(),
@@ -294,23 +298,20 @@ class MCPCostValidationEngine:
             tolerance_threshold=self.tolerance_percent,
             validation_recommendations=recommendations,
             performance_metrics={
-                'validation_time_seconds': validation_time,
-                'api_calls': 2,  # Estimate for Cost Explorer + Organizations
-                'data_freshness_minutes': 15  # Cost Explorer data freshness
+                "validation_time_seconds": validation_time,
+                "api_calls": 2,  # Estimate for Cost Explorer + Organizations
+                "data_freshness_minutes": 15,  # Cost Explorer data freshness
             },
-            evidence_files={}
+            evidence_files={},
         )
 
     async def _generate_test_evidence(
-        self,
-        scenario_name: str,
-        cost_result: CostOptimizationResult,
-        mcp_validation: MCPValidationResult
+        self, scenario_name: str, cost_result: CostOptimizationResult, mcp_validation: MCPValidationResult
     ) -> Dict[str, str]:
         """Generate comprehensive test evidence for DoD validation."""
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         evidence_files = {}
-        
+
         try:
             # Generate JSON evidence file
             evidence_data = {
@@ -322,119 +323,121 @@ class MCPCostValidationEngine:
                     "resources_analyzed": cost_result.resources_analyzed,
                     "resources_impacted": len(cost_result.resources_impacted),
                     "execution_mode": cost_result.execution_mode.value,
-                    "risk_level": cost_result.business_metrics.overall_risk_level.value
+                    "risk_level": cost_result.business_metrics.overall_risk_level.value,
                 },
                 "mcp_validation": asdict(mcp_validation),
                 "performance_metrics": {
                     "total_execution_time_seconds": time.time() - self.start_time,
                     "api_calls_made": self.api_calls_made,
-                    "cost_data_points": self.cost_data_points
+                    "cost_data_points": self.cost_data_points,
                 },
                 "dod_compliance": {
                     "real_aws_data_used": True,
                     "mcp_cross_validation": mcp_validation.mcp_enabled,
                     "variance_within_tolerance": mcp_validation.variance_within_tolerance,
                     "evidence_generated": True,
-                    "performance_target_met": mcp_validation.performance_metrics.get('validation_time_seconds', 0) < 30
-                }
+                    "performance_target_met": mcp_validation.performance_metrics.get("validation_time_seconds", 0) < 30,
+                },
             }
-            
+
             json_file = self.evidence_dir / f"{scenario_name}_{timestamp}.json"
-            with open(json_file, 'w') as f:
+            with open(json_file, "w") as f:
                 json.dump(evidence_data, f, indent=2, default=str)
-            evidence_files['json'] = str(json_file)
-            
+            evidence_files["json"] = str(json_file)
+
             # Generate CSV summary for business stakeholders
             csv_file = self.evidence_dir / f"{scenario_name}_summary_{timestamp}.csv"
-            with open(csv_file, 'w', newline='') as f:
+            with open(csv_file, "w", newline="") as f:
                 writer = csv.writer(f)
-                writer.writerow([
-                    'Scenario', 'Success', 'Monthly Savings', 'MCP Validated', 
-                    'Variance %', 'Performance Met', 'Evidence Generated'
-                ])
-                writer.writerow([
-                    scenario_name,
-                    'YES' if cost_result.success else 'NO',
-                    f"${cost_result.business_metrics.total_monthly_savings:,.2f}",
-                    'YES' if mcp_validation.mcp_enabled else 'NO',
-                    f"{mcp_validation.variance_percentage:.2f}%",
-                    'YES' if mcp_validation.performance_metrics.get('validation_time_seconds', 0) < 30 else 'NO',
-                    'YES'
-                ])
-            evidence_files['csv'] = str(csv_file)
-            
+                writer.writerow(
+                    [
+                        "Scenario",
+                        "Success",
+                        "Monthly Savings",
+                        "MCP Validated",
+                        "Variance %",
+                        "Performance Met",
+                        "Evidence Generated",
+                    ]
+                )
+                writer.writerow(
+                    [
+                        scenario_name,
+                        "YES" if cost_result.success else "NO",
+                        f"${cost_result.business_metrics.total_monthly_savings:,.2f}",
+                        "YES" if mcp_validation.mcp_enabled else "NO",
+                        f"{mcp_validation.variance_percentage:.2f}%",
+                        "YES" if mcp_validation.performance_metrics.get("validation_time_seconds", 0) < 30 else "NO",
+                        "YES",
+                    ]
+                )
+            evidence_files["csv"] = str(csv_file)
+
             print_success(f"📄 Evidence generated: {len(evidence_files)} files")
-            
+
         except Exception as e:
             print_warning(f"Evidence generation encountered an issue: {str(e)}")
-            evidence_files['error'] = str(e)
-        
+            evidence_files["error"] = str(e)
+
         return evidence_files
 
     async def run_comprehensive_cli_test_suite(self) -> List[TechnicalTestResult]:
         """
         Run comprehensive CLI test suite for technical users and DoD validation.
-        
+
         Returns:
             List of TechnicalTestResult objects with detailed validation results
         """
         print_header("Comprehensive CLI Test Suite - Technical Validation")
-        
+
         # Define test scenarios with business-realistic parameters
         test_scenarios = [
             {
-                'name': 'nat_gateway_cost_optimization',
-                'params': {
-                    'profile': self.billing_profile,
-                    'regions': ['us-east-1', 'us-west-2'],
-                    'idle_threshold_days': 7,
-                    'cost_threshold': 100.0
+                "name": "nat_gateway_cost_optimization",
+                "params": {
+                    "profile": self.billing_profile,
+                    "regions": ["us-east-1", "us-west-2"],
+                    "idle_threshold_days": 7,
+                    "cost_threshold": 100.0,
                 },
-                'expected_savings_range': (0.0, 5000.0)  # 0-$5K/month realistic range
+                "expected_savings_range": (0.0, 5000.0),  # 0-$5K/month realistic range
             },
             {
-                'name': 'ec2_idle_instance_optimization',
-                'params': {
-                    'profile': self.billing_profile,
-                    'regions': ['us-east-1'],
-                    'cpu_threshold': 5.0,
-                    'duration_hours': 168,  # 7 days
-                    'cost_threshold': 50.0
+                "name": "ec2_idle_instance_optimization",
+                "params": {
+                    "profile": self.billing_profile,
+                    "regions": ["us-east-1"],
+                    "cpu_threshold": 5.0,
+                    "duration_hours": 168,  # 7 days
+                    "cost_threshold": 50.0,
                 },
-                'expected_savings_range': (0.0, 10000.0)  # 0-$10K/month realistic range  
+                "expected_savings_range": (0.0, 10000.0),  # 0-$10K/month realistic range
             },
             {
-                'name': 'emergency_response_validation',
-                'params': {
-                    'profile': self.billing_profile,
-                    'cost_spike_threshold': 25000.0,
-                    'analysis_days': 7
-                },
-                'expected_savings_range': (5000.0, 15000.0)  # measurable range/month emergency response
-            }
+                "name": "emergency_response_validation",
+                "params": {"profile": self.billing_profile, "cost_spike_threshold": 25000.0, "analysis_days": 7},
+                "expected_savings_range": (5000.0, 15000.0),  # measurable range/month emergency response
+            },
         ]
-        
+
         test_results = []
-        
+
         # Execute test scenarios with progress tracking
         with create_progress_bar() as progress:
-            task = progress.add_task(
-                "[cyan]Executing technical test scenarios...", 
-                total=len(test_scenarios)
-            )
-            
+            task = progress.add_task("[cyan]Executing technical test scenarios...", total=len(test_scenarios))
+
             for scenario in test_scenarios:
                 print_info(f"🧪 Executing: {scenario['name']}")
-                
+
                 result = await self.validate_cost_optimization_scenario(
-                    scenario_name=scenario['name'],
-                    cost_optimizer_params=scenario['params'],
-                    expected_savings_range=scenario['expected_savings_range']
+                    scenario_name=scenario["name"],
+                    cost_optimizer_params=scenario["params"],
+                    expected_savings_range=scenario["expected_savings_range"],
                 )
-                
+
                 test_results.append(result)
                 progress.advance(task)
-                
+
                 # Display individual test result
                 if result.success:
                     print_success(f"✅ {scenario['name']}: PASSED")
@@ -442,27 +445,27 @@ class MCPCostValidationEngine:
                     print_error(f"❌ {scenario['name']}: FAILED")
                     if result.error_message:
                         print_warning(f"   Error: {result.error_message}")
-        
+
         # Display comprehensive test summary
         self._display_test_suite_summary(test_results)
-        
+
         return test_results
 
     def _display_test_suite_summary(self, test_results: List[TechnicalTestResult]) -> None:
         """Display comprehensive test suite summary with DoD validation metrics."""
-        
+
         # Calculate aggregate metrics
         total_tests = len(test_results)
         passed_tests = sum(1 for r in test_results if r.success)
         failed_tests = total_tests - passed_tests
-        
+
         total_execution_time = sum(r.execution_time_ms for r in test_results)
         avg_execution_time = total_execution_time / total_tests if total_tests > 0 else 0
-        
+
         performance_met = sum(1 for r in test_results if r.performance_benchmark_met)
         mcp_validated = sum(1 for r in test_results if r.mcp_validation and r.mcp_validation.mcp_enabled)
         evidence_generated = sum(1 for r in test_results if r.evidence_generated)
-        
+
         # Create summary table
         summary_table = create_table(
             title="Technical Test Suite Summary - DoD Validation",
@@ -472,38 +475,31 @@ class MCPCostValidationEngine:
                 {"name": "Execution (ms)", "style": "yellow"},
                 {"name": "MCP Validated", "style": "blue"},
                 {"name": "Performance", "style": "magenta"},
-                {"name": "Evidence", "style": "white"}
-            ]
+                {"name": "Evidence", "style": "white"},
+            ],
         )
-        
+
         for result in test_results:
             status = "✅ PASS" if result.success else "❌ FAIL"
             mcp_status = "✅" if result.mcp_validation and result.mcp_validation.mcp_enabled else "❌"
             perf_status = "✅" if result.performance_benchmark_met else "❌"
             evidence_status = "✅" if result.evidence_generated else "❌"
-            
+
             summary_table.add_row(
-                result.test_name,
-                status,
-                f"{result.execution_time_ms:.0f}ms",
-                mcp_status,
-                perf_status,
-                evidence_status
+                result.test_name, status, f"{result.execution_time_ms:.0f}ms", mcp_status, perf_status, evidence_status
             )
-        
+
         console.print(summary_table)
-        
+
         # Overall DoD compliance summary
-        dod_compliance_score = (
-            (passed_tests / total_tests * 100) if total_tests > 0 else 0
-        )
-        
+        dod_compliance_score = (passed_tests / total_tests * 100) if total_tests > 0 else 0
+
         dod_panel = create_panel(
             f"""📊 DoD Validation Summary
 
 ✅ Test Results:
    • Tests executed: {total_tests}
-   • Tests passed: {passed_tests} ({passed_tests/total_tests*100:.1f}%)
+   • Tests passed: {passed_tests} ({passed_tests / total_tests * 100:.1f}%)
    • Tests failed: {failed_tests}
 
 ⚡ Performance Metrics:
@@ -513,20 +509,20 @@ class MCPCostValidationEngine:
 
 🔍 MCP Validation:
    • MCP cross-validation: {mcp_validated}/{total_tests}
-   • Cost Explorer integration: {'✅ Active' if mcp_validated > 0 else '❌ Inactive'}
-   • Data accuracy validation: {'✅ Enabled' if mcp_validated > 0 else '❌ Disabled'}
+   • Cost Explorer integration: {"✅ Active" if mcp_validated > 0 else "❌ Inactive"}
+   • Data accuracy validation: {"✅ Enabled" if mcp_validated > 0 else "❌ Disabled"}
 
 📄 Evidence Generation:
    • Evidence files created: {evidence_generated}/{total_tests}
-   • DoD compliance documentation: {'✅ Complete' if evidence_generated == total_tests else '⚠️ Partial'}
+   • DoD compliance documentation: {"✅ Complete" if evidence_generated == total_tests else "⚠️ Partial"}
 
 🎯 Overall DoD Compliance Score: {dod_compliance_score:.1f}%""",
             title="DoD Validation Results",
-            border_style="green" if dod_compliance_score >= 90 else "yellow" if dod_compliance_score >= 70 else "red"
+            border_style="green" if dod_compliance_score >= 90 else "yellow" if dod_compliance_score >= 70 else "red",
         )
-        
+
         console.print(dod_panel)
-        
+
         # Success criteria evaluation
         if dod_compliance_score >= 90 and mcp_validated >= total_tests * 0.8:
             print_success("🎯 DoD VALIDATION COMPLETE - All criteria met")
@@ -542,7 +538,7 @@ class MCPCostValidationEngine:
         """Export comprehensive DoD validation report for technical documentation."""
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         report_file = self.evidence_dir / f"dod_validation_report_{timestamp}.json"
-        
+
         # Aggregate all validation data
         dod_report = {
             "validation_metadata": {
@@ -551,128 +547,149 @@ class MCPCostValidationEngine:
                 "billing_profile": self.billing_profile,
                 "management_profile": self.management_profile,
                 "tolerance_threshold": self.tolerance_percent,
-                "performance_target_ms": self.performance_target_ms
+                "performance_target_ms": self.performance_target_ms,
             },
             "test_execution_summary": {
                 "total_tests_executed": len(test_results),
                 "tests_passed": sum(1 for r in test_results if r.success),
                 "tests_failed": sum(1 for r in test_results if not r.success),
-                "overall_success_rate": (sum(1 for r in test_results if r.success) / len(test_results) * 100) if test_results else 0,
+                "overall_success_rate": (sum(1 for r in test_results if r.success) / len(test_results) * 100)
+                if test_results
+                else 0,
                 "total_execution_time_ms": sum(r.execution_time_ms for r in test_results),
-                "average_execution_time_ms": sum(r.execution_time_ms for r in test_results) / len(test_results) if test_results else 0
+                "average_execution_time_ms": sum(r.execution_time_ms for r in test_results) / len(test_results)
+                if test_results
+                else 0,
             },
             "mcp_validation_metrics": {
-                "mcp_integrations_successful": sum(1 for r in test_results if r.mcp_validation and r.mcp_validation.mcp_enabled),
-                "cost_explorer_validations": sum(1 for r in test_results if r.mcp_validation and r.mcp_validation.cost_explorer_validated),
-                "variance_within_tolerance": sum(1 for r in test_results if r.mcp_validation and r.mcp_validation.variance_within_tolerance),
-                "average_variance_percentage": sum(r.mcp_validation.variance_percentage for r in test_results if r.mcp_validation) / len(test_results) if test_results else 0
+                "mcp_integrations_successful": sum(
+                    1 for r in test_results if r.mcp_validation and r.mcp_validation.mcp_enabled
+                ),
+                "cost_explorer_validations": sum(
+                    1 for r in test_results if r.mcp_validation and r.mcp_validation.cost_explorer_validated
+                ),
+                "variance_within_tolerance": sum(
+                    1 for r in test_results if r.mcp_validation and r.mcp_validation.variance_within_tolerance
+                ),
+                "average_variance_percentage": sum(
+                    r.mcp_validation.variance_percentage for r in test_results if r.mcp_validation
+                )
+                / len(test_results)
+                if test_results
+                else 0,
             },
             "performance_benchmarks": {
                 "performance_targets_met": sum(1 for r in test_results if r.performance_benchmark_met),
-                "performance_compliance_rate": (sum(1 for r in test_results if r.performance_benchmark_met) / len(test_results) * 100) if test_results else 0,
+                "performance_compliance_rate": (
+                    sum(1 for r in test_results if r.performance_benchmark_met) / len(test_results) * 100
+                )
+                if test_results
+                else 0,
                 "aws_api_calls_total": sum(r.aws_api_calls for r in test_results),
-                "cost_data_points_analyzed": sum(r.cost_data_points for r in test_results)
+                "cost_data_points_analyzed": sum(r.cost_data_points for r in test_results),
             },
             "evidence_generation": {
                 "evidence_files_created": sum(1 for r in test_results if r.evidence_generated),
-                "evidence_generation_rate": (sum(1 for r in test_results if r.evidence_generated) / len(test_results) * 100) if test_results else 0,
-                "evidence_directory": str(self.evidence_dir)
+                "evidence_generation_rate": (
+                    sum(1 for r in test_results if r.evidence_generated) / len(test_results) * 100
+                )
+                if test_results
+                else 0,
+                "evidence_directory": str(self.evidence_dir),
             },
             "detailed_test_results": [asdict(result) for result in test_results],
             "dod_compliance_assessment": {
                 "requirements_met": {
-                    "real_aws_data_integration": sum(1 for r in test_results if r.mcp_validation and r.mcp_validation.mcp_enabled) > 0,
-                    "cross_validation_enabled": sum(1 for r in test_results if r.mcp_validation and r.mcp_validation.cost_explorer_validated) > 0,
-                    "performance_targets_achieved": sum(1 for r in test_results if r.performance_benchmark_met) >= len(test_results) * 0.8,
-                    "evidence_documentation_complete": sum(1 for r in test_results if r.evidence_generated) == len(test_results),
-                    "error_handling_validated": sum(1 for r in test_results if r.error_message is not None) < len(test_results) * 0.2
+                    "real_aws_data_integration": sum(
+                        1 for r in test_results if r.mcp_validation and r.mcp_validation.mcp_enabled
+                    )
+                    > 0,
+                    "cross_validation_enabled": sum(
+                        1 for r in test_results if r.mcp_validation and r.mcp_validation.cost_explorer_validated
+                    )
+                    > 0,
+                    "performance_targets_achieved": sum(1 for r in test_results if r.performance_benchmark_met)
+                    >= len(test_results) * 0.8,
+                    "evidence_documentation_complete": sum(1 for r in test_results if r.evidence_generated)
+                    == len(test_results),
+                    "error_handling_validated": sum(1 for r in test_results if r.error_message is not None)
+                    < len(test_results) * 0.2,
                 },
-                "overall_compliance_score": 0.0  # Will be calculated below
-            }
+                "overall_compliance_score": 0.0,  # Will be calculated below
+            },
         }
-        
+
         # Calculate overall DoD compliance score
         requirements_met = dod_report["dod_compliance_assessment"]["requirements_met"]
         compliance_score = sum(requirements_met.values()) / len(requirements_met) * 100
         dod_report["dod_compliance_assessment"]["overall_compliance_score"] = compliance_score
-        
+
         # Export report
         try:
-            with open(report_file, 'w') as f:
+            with open(report_file, "w") as f:
                 json.dump(dod_report, f, indent=2, default=str)
-            
+
             print_success(f"📊 DoD validation report exported: {report_file}")
             return str(report_file)
-            
+
         except Exception as e:
             print_error(f"Failed to export DoD validation report: {str(e)}")
             return ""
 
+
 # CLI command interface for technical users
 async def main_cli():
     """Main CLI entry point for technical cost optimization validation."""
     import argparse
-    
-    parser = argparse.ArgumentParser(
-        description="MCP-Validated Cost Optimization - Technical CLI Interface"
-    )
+
+    parser = argparse.ArgumentParser(description="MCP-Validated Cost Optimization - Technical CLI Interface")
     parser.add_argument(
-        "--billing-profile", 
-        default="${BILLING_PROFILE}",
-        help="AWS billing profile with Cost Explorer access"
+        "--billing-profile", default="${BILLING_PROFILE}", help="AWS billing profile with Cost Explorer access"
     )
     parser.add_argument(
-        "--management-profile",
-        default="${MANAGEMENT_PROFILE}", 
-        help="AWS management profile with Organizations access"
+        "--management-profile", default="${MANAGEMENT_PROFILE}", help="AWS management profile with Organizations access"
     )
     parser.add_argument(
-        "--tolerance-percent",
-        type=float,
-        default=5.0,
-        help="MCP cross-validation tolerance percentage (default: 5.0)"
+        "--tolerance-percent", type=float, default=5.0, help="MCP cross-validation tolerance percentage (default: 5.0)"
     )
     parser.add_argument(
-        "--performance-target-ms", 
+        "--performance-target-ms",
         type=float,
         default=30000.0,
-        help="Performance target in milliseconds (default: 30000)"
+        help="Performance target in milliseconds (default: 30000)",
     )
-    parser.add_argument(
-        "--run-full-suite",
-        action="store_true",
-        help="Run complete DoD validation test suite"
-    )
-    
+    parser.add_argument("--run-full-suite", action="store_true", help="Run complete DoD validation test suite")
+
     args = parser.parse_args()
-    
+
     # Initialize MCP validation engine
     validation_engine = MCPCostValidationEngine(
         billing_profile=args.billing_profile,
         management_profile=args.management_profile,
         tolerance_percent=args.tolerance_percent,
-        performance_target_ms=args.performance_target_ms
+        performance_target_ms=args.performance_target_ms,
     )
-    
+
     if args.run_full_suite:
         # Run comprehensive test suite
         test_results = await validation_engine.run_comprehensive_cli_test_suite()
-        
+
         # Export DoD validation report
         report_file = await validation_engine.export_dod_validation_report(test_results)
-        
+
         if report_file:
             print_success(f"✅ Comprehensive DoD validation complete: {report_file}")
         else:
             print_error("❌ DoD validation encountered issues")
-            
+
     else:
         # Run individual scenario validation
         print_info("💡 Use --run-full-suite for comprehensive DoD validation")
         print_info("📖 Available scenarios:")
         print_info("   • nat_gateway_cost_optimization")
-        print_info("   • ec2_idle_instance_optimization")  
+        print_info("   • ec2_idle_instance_optimization")
         print_info("   • emergency_response_validation")
 
+
 if __name__ == "__main__":
-    asyncio.run(main_cli())
+    asyncio.run(main_cli())