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

runbooks/finops/validation_framework.py

@@ -1,5 +1,5 @@
 """
-✅ CloudOps-Automation Validation Framework Module  
+✅ CloudOps-Automation Validation Framework Module
 MCP Validation Patterns for CloudOps Consolidation
 
 Strategic Achievement: Validation framework ensuring ≥99.5% accuracy for all
@@ -16,30 +16,37 @@ Key Features:
 - Quality gates enforcement for enterprise operations
 
 Author: Enterprise Agile Team (6-Agent Coordination)
-Version: latest version - Distributed Architecture Framework  
+Version: latest version - Distributed Architecture Framework
 """
 
-import os
+import hashlib
 import json
+import os
 import time
-import hashlib
-from typing import Dict, List, Optional, Any, Union, Tuple
 from dataclasses import dataclass, field
-from enum import Enum
 from datetime import datetime, timedelta
-from decimal import Decimal, ROUND_HALF_UP
+from decimal import ROUND_HALF_UP, Decimal
+from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 from ..common.rich_utils import (
-    console, print_header, print_success, print_warning, print_error,
-    create_table, create_progress_bar, format_cost
+    console,
+    create_progress_bar,
+    create_table,
+    format_cost,
+    print_error,
+    print_header,
+    print_success,
+    print_warning,
 )
 from .accuracy_cross_validator import AccuracyLevel
 
 
 class ValidationStatus(Enum):
     """Validation status enumeration."""
+
     PENDING = "pending"
-    IN_PROGRESS = "in_progress" 
+    IN_PROGRESS = "in_progress"
     PASSED = "passed"
     FAILED = "failed"
     WARNING = "warning"
@@ -48,24 +55,27 @@ class ValidationStatus(Enum):
 
 class AccuracyThreshold(Enum):
     """Accuracy threshold levels for different operation types."""
-    COST_CRITICAL = 99.9        # Cost calculations must be extremely accurate
+
+    COST_CRITICAL = 99.9  # Cost calculations must be extremely accurate
     ENTERPRISE_STANDARD = 99.5  # Enterprise standard accuracy requirement
-    OPERATIONAL = 95.0          # Operational tasks standard
-    INFORMATIONAL = 90.0        # Informational reporting
+    OPERATIONAL = 95.0  # Operational tasks standard
+    INFORMATIONAL = 90.0  # Informational reporting
 
 
 class ValidationScope(Enum):
     """Scope of validation operations."""
-    SINGLE_RESOURCE = "single_resource"       # Validate individual resource
-    RESOURCE_GROUP = "resource_group"         # Validate related resources
-    ACCOUNT_WIDE = "account_wide"             # Validate entire AWS account
-    CROSS_ACCOUNT = "cross_account"           # Validate across multiple accounts
-    PORTFOLIO_WIDE = "portfolio_wide"         # Validate entire enterprise portfolio
+
+    SINGLE_RESOURCE = "single_resource"  # Validate individual resource
+    RESOURCE_GROUP = "resource_group"  # Validate related resources
+    ACCOUNT_WIDE = "account_wide"  # Validate entire AWS account
+    CROSS_ACCOUNT = "cross_account"  # Validate across multiple accounts
+    PORTFOLIO_WIDE = "portfolio_wide"  # Validate entire enterprise portfolio
 
 
 @dataclass
 class ValidationMetrics:
     """Comprehensive validation metrics for MCP operations."""
+
     validation_id: str
     operation_name: str
     accuracy_percentage: float
@@ -82,6 +92,7 @@ class ValidationMetrics:
 @dataclass
 class MCPValidationResult:
     """Result of MCP validation operation with comprehensive details."""
+
     validation_metrics: ValidationMetrics
     business_impact: Dict[str, Any]
     technical_validation: Dict[str, Any]
@@ -95,20 +106,20 @@ class MCPValidationResult:
 class MCPValidator:
     """
     MCP (Model Context Protocol) validator for CloudOps-Automation operations.
-    
+
     Provides comprehensive validation against real AWS APIs with accuracy measurement,
     evidence collection, and quality gates enforcement.
     """
-    
+
     def __init__(
-        self, 
+        self,
         accuracy_threshold: float = 99.5,
         validation_scope: ValidationScope = ValidationScope.ACCOUNT_WIDE,
-        evidence_collection: bool = True
+        evidence_collection: bool = True,
     ):
         """
         Initialize MCP validator.
-        
+
         Args:
             accuracy_threshold: Minimum accuracy percentage required (default 99.5%)
             validation_scope: Scope of validation operations
@@ -118,47 +129,47 @@ class MCPValidator:
         self.validation_scope = validation_scope
         self.evidence_collection = evidence_collection
         self.validation_history: List[MCPValidationResult] = []
-        
+
         # Performance tracking
         self.performance_targets = {
             "max_validation_time_seconds": 30.0,
             "max_discrepancy_rate": 0.5,  # 0.5% maximum discrepancy rate
-            "min_confidence_score": 0.95
+            "min_confidence_score": 0.95,
         }
-    
+
     def validate_cost_analysis(
-        self, 
+        self,
         runbooks_data: Dict[str, Any],
         aws_profile: Optional[str] = None,
-        time_period: Optional[Dict[str, str]] = None
+        time_period: Optional[Dict[str, str]] = None,
     ) -> MCPValidationResult:
         """
         Validate cost analysis data against AWS Cost Explorer API.
-        
-        Strategic Focus: Ensure cost calculations meet ≥99.5% accuracy for 
+
+        Strategic Focus: Ensure cost calculations meet ≥99.5% accuracy for
         enterprise financial decision making.
         """
         print_header("MCP Cost Validation", "Accuracy Framework latest version")
-        
+
         validation_start = time.time()
         validation_id = self._generate_validation_id("cost_analysis")
-        
+
         try:
             # Extract cost data from runbooks result
             runbooks_costs = self._extract_cost_data(runbooks_data)
-            
+
             # Fetch real AWS cost data for comparison
             aws_costs = self._fetch_aws_cost_data(aws_profile, time_period)
-            
+
             # Perform detailed comparison
             comparison_result = self._compare_cost_data(runbooks_costs, aws_costs)
-            
+
             # Calculate accuracy metrics
             accuracy_percentage = self._calculate_accuracy_percentage(comparison_result)
-            
+
             # Performance benchmarking
             validation_time = time.time() - validation_start
-            
+
             # Create validation metrics
             validation_metrics = ValidationMetrics(
                 validation_id=validation_id,
@@ -172,43 +183,39 @@ class MCPValidator:
                 performance_benchmarks={
                     "validation_time": validation_time,
                     "records_per_second": len(runbooks_costs) / max(validation_time, 0.1),
-                    "accuracy_target_met": accuracy_percentage >= self.accuracy_threshold
-                }
+                    "accuracy_target_met": accuracy_percentage >= self.accuracy_threshold,
+                },
             )
-            
+
             # Generate evidence artifacts if enabled
             if self.evidence_collection:
                 evidence_artifacts = self._generate_evidence_artifacts(
                     validation_id, comparison_result, runbooks_costs, aws_costs
                 )
                 validation_metrics.evidence_artifacts = evidence_artifacts
-            
+
             # Business impact assessment
-            business_impact = self._assess_business_impact(
-                accuracy_percentage, comparison_result, validation_metrics
-            )
-            
+            business_impact = self._assess_business_impact(accuracy_percentage, comparison_result, validation_metrics)
+
             # Technical validation details
             technical_validation = {
                 "data_sources": {
                     "runbooks": "CloudOps-Runbooks CLI output",
-                    "aws_api": f"AWS Cost Explorer API (profile: {aws_profile or 'default'})"
+                    "aws_api": f"AWS Cost Explorer API (profile: {aws_profile or 'default'})",
                 },
                 "validation_method": "Point-in-time cost comparison with tolerance adjustment",
                 "time_synchronization": time_period or "Auto-aligned periods",
-                "validation_scope": self.validation_scope.value
+                "validation_scope": self.validation_scope.value,
             }
-            
+
             # Quality gates assessment
             quality_gates = self._assess_quality_gates(validation_metrics)
-            
+
             # Recommendations based on validation result
-            recommendations = self._generate_recommendations(
-                accuracy_percentage, validation_metrics, comparison_result
-            )
-            
+            recommendations = self._generate_recommendations(accuracy_percentage, validation_metrics, comparison_result)
+
             print_success(f"Cost Validation Complete: {accuracy_percentage:.2f}% accuracy")
-            
+
             result = MCPValidationResult(
                 validation_metrics=validation_metrics,
                 business_impact=business_impact,
@@ -217,47 +224,47 @@ class MCPValidator:
                 recommendations=recommendations,
                 quality_gates_status=quality_gates,
                 raw_comparison_data=comparison_result,
-                validation_evidence={"artifacts_generated": len(validation_metrics.evidence_artifacts)}
+                validation_evidence={"artifacts_generated": len(validation_metrics.evidence_artifacts)},
             )
-            
+
             self.validation_history.append(result)
             return result
-            
+
         except Exception as e:
             return self._create_validation_error(
                 validation_id, "cost_analysis_validation", str(e), time.time() - validation_start
             )
-    
+
     def validate_resource_discovery(
         self,
         runbooks_data: Dict[str, Any],
         aws_profile: Optional[str] = None,
-        resource_types: Optional[List[str]] = None
+        resource_types: Optional[List[str]] = None,
     ) -> MCPValidationResult:
         """
         Validate resource discovery data against AWS APIs.
-        
+
         Focus: Ensure resource counts and attributes match AWS reality.
         """
         print_header("MCP Resource Validation", "Discovery Framework latest version")
-        
+
         validation_start = time.time()
         validation_id = self._generate_validation_id("resource_discovery")
-        
+
         try:
             # Extract resource data
             runbooks_resources = self._extract_resource_data(runbooks_data)
-            
+
             # Fetch AWS resource data
             aws_resources = self._fetch_aws_resource_data(aws_profile, resource_types)
-            
+
             # Compare resource data
             comparison_result = self._compare_resource_data(runbooks_resources, aws_resources)
-            
+
             # Calculate accuracy
             accuracy_percentage = self._calculate_resource_accuracy(comparison_result)
             validation_time = time.time() - validation_start
-            
+
             validation_metrics = ValidationMetrics(
                 validation_id=validation_id,
                 operation_name="resource_discovery_validation",
@@ -269,18 +276,18 @@ class MCPValidator:
                 confidence_score=self._calculate_confidence_score(comparison_result),
                 performance_benchmarks={
                     "discovery_time": validation_time,
-                    "resources_per_second": len(runbooks_resources) / max(validation_time, 0.1)
-                }
+                    "resources_per_second": len(runbooks_resources) / max(validation_time, 0.1),
+                },
             )
-            
+
             business_impact = {
                 "resource_accuracy": f"{accuracy_percentage:.2f}%",
                 "discovery_reliability": "High" if accuracy_percentage >= 95.0 else "Medium",
-                "operational_confidence": "Validated against real AWS APIs"
+                "operational_confidence": "Validated against real AWS APIs",
             }
-            
+
             print_success(f"Resource Validation Complete: {accuracy_percentage:.2f}% accuracy")
-            
+
             result = MCPValidationResult(
                 validation_metrics=validation_metrics,
                 business_impact=business_impact,
@@ -289,39 +296,37 @@ class MCPValidator:
                 recommendations=["Resource discovery accuracy acceptable"],
                 quality_gates_status={"discovery_gate": accuracy_percentage >= AccuracyLevel.OPERATIONAL.value},
                 raw_comparison_data=comparison_result,
-                validation_evidence={}
+                validation_evidence={},
             )
-            
+
             self.validation_history.append(result)
             return result
-            
+
         except Exception as e:
             return self._create_validation_error(
                 validation_id, "resource_discovery_validation", str(e), time.time() - validation_start
             )
-    
+
     def validate_optimization_recommendations(
-        self,
-        recommendations_data: Dict[str, Any],
-        aws_profile: Optional[str] = None
+        self, recommendations_data: Dict[str, Any], aws_profile: Optional[str] = None
     ) -> MCPValidationResult:
         """
         Validate optimization recommendations against current AWS state.
-        
+
         Focus: Ensure recommendations are based on accurate current state analysis.
         """
         print_header("MCP Optimization Validation", "Recommendations Framework latest version")
-        
+
         validation_start = time.time()
         validation_id = self._generate_validation_id("optimization_recommendations")
-        
+
         try:
             # Validate recommendation accuracy
             validation_results = self._validate_recommendations(recommendations_data, aws_profile)
-            
+
             accuracy_percentage = validation_results.get("accuracy", 0.0)
             validation_time = time.time() - validation_start
-            
+
             validation_metrics = ValidationMetrics(
                 validation_id=validation_id,
                 operation_name="optimization_recommendations_validation",
@@ -330,17 +335,17 @@ class MCPValidator:
                 execution_time_seconds=validation_time,
                 records_validated=validation_results.get("recommendations_count", 0),
                 discrepancies_found=validation_results.get("invalid_recommendations", 0),
-                confidence_score=accuracy_percentage / 100.0
+                confidence_score=accuracy_percentage / 100.0,
             )
-            
+
             business_impact = {
                 "recommendation_reliability": f"{accuracy_percentage:.1f}%",
                 "implementation_confidence": "High" if accuracy_percentage >= self.accuracy_threshold else "Medium",
-                "business_value_accuracy": "Validated savings calculations"
+                "business_value_accuracy": "Validated savings calculations",
             }
-            
+
             print_success(f"Optimization Validation Complete: {accuracy_percentage:.2f}% accuracy")
-            
+
             result = MCPValidationResult(
                 validation_metrics=validation_metrics,
                 business_impact=business_impact,
@@ -349,187 +354,182 @@ class MCPValidator:
                 recommendations=["Recommendations validated against current AWS state"],
                 quality_gates_status={"optimization_gate": accuracy_percentage >= self.accuracy_threshold},
                 raw_comparison_data=validation_results,
-                validation_evidence={}
+                validation_evidence={},
             )
-            
+
             self.validation_history.append(result)
             return result
-            
+
         except Exception as e:
             return self._create_validation_error(
                 validation_id, "optimization_recommendations", str(e), time.time() - validation_start
             )
-    
+
     def generate_validation_summary(self) -> Dict[str, Any]:
         """
         Generate comprehensive validation summary across all operations.
-        
+
         Strategic Output: Executive-ready validation report with quality metrics.
         """
         if not self.validation_history:
             return {"status": "no_validations_performed"}
-        
+
         # Aggregate validation metrics
         total_validations = len(self.validation_history)
-        passed_validations = len([v for v in self.validation_history if v.validation_metrics.validation_status == ValidationStatus.PASSED])
-        
-        average_accuracy = sum(v.validation_metrics.accuracy_percentage for v in self.validation_history) / total_validations
-        average_execution_time = sum(v.validation_metrics.execution_time_seconds for v in self.validation_history) / total_validations
-        
+        passed_validations = len(
+            [v for v in self.validation_history if v.validation_metrics.validation_status == ValidationStatus.PASSED]
+        )
+
+        average_accuracy = (
+            sum(v.validation_metrics.accuracy_percentage for v in self.validation_history) / total_validations
+        )
+        average_execution_time = (
+            sum(v.validation_metrics.execution_time_seconds for v in self.validation_history) / total_validations
+        )
+
         total_records_validated = sum(v.validation_metrics.records_validated for v in self.validation_history)
         total_discrepancies = sum(v.validation_metrics.discrepancies_found for v in self.validation_history)
-        
+
         # Performance assessment
         performance_assessment = {
             "average_accuracy": f"{average_accuracy:.2f}%",
-            "accuracy_target_achievement": f"{(passed_validations/total_validations)*100:.1f}%",
+            "accuracy_target_achievement": f"{(passed_validations / total_validations) * 100:.1f}%",
             "average_execution_time": f"{average_execution_time:.2f}s",
             "performance_target_met": average_execution_time <= self.performance_targets["max_validation_time_seconds"],
             "total_operations_validated": total_validations,
-            "enterprise_standard_compliance": average_accuracy >= self.accuracy_threshold
+            "enterprise_standard_compliance": average_accuracy >= self.accuracy_threshold,
         }
-        
+
         # Quality gates summary
         quality_summary = {
-            "validation_success_rate": f"{(passed_validations/total_validations)*100:.1f}%",
-            "discrepancy_rate": f"{(total_discrepancies/max(total_records_validated,1))*100:.3f}%",
-            "evidence_collection_rate": f"{len([v for v in self.validation_history if v.validation_metrics.evidence_artifacts])/total_validations*100:.1f}%"
+            "validation_success_rate": f"{(passed_validations / total_validations) * 100:.1f}%",
+            "discrepancy_rate": f"{(total_discrepancies / max(total_records_validated, 1)) * 100:.3f}%",
+            "evidence_collection_rate": f"{len([v for v in self.validation_history if v.validation_metrics.evidence_artifacts]) / total_validations * 100:.1f}%",
         }
-        
+
         return {
             "validation_summary": {
                 "total_validations": total_validations,
                 "validation_period": f"{self.validation_history[0].validation_metrics.timestamp} to {self.validation_history[-1].validation_metrics.timestamp}",
-                "accuracy_threshold": f"{self.accuracy_threshold}%"
+                "accuracy_threshold": f"{self.accuracy_threshold}%",
             },
             "performance_metrics": performance_assessment,
             "quality_assessment": quality_summary,
             "enterprise_compliance": {
                 "accuracy_standard_met": average_accuracy >= self.accuracy_threshold,
                 "performance_standard_met": average_execution_time <= 30.0,
-                "evidence_collection_enabled": self.evidence_collection
-            }
+                "evidence_collection_enabled": self.evidence_collection,
+            },
         }
-    
+
     def _extract_cost_data(self, runbooks_data: Dict[str, Any]) -> Dict[str, float]:
         """Extract cost information from runbooks output."""
         cost_data = {}
-        
+
         # Handle different runbooks output formats
-        if 'services' in runbooks_data:
-            for service, data in runbooks_data['services'].items():
-                if isinstance(data, dict) and 'cost' in data:
-                    cost_data[service] = float(data['cost'])
+        if "services" in runbooks_data:
+            for service, data in runbooks_data["services"].items():
+                if isinstance(data, dict) and "cost" in data:
+                    cost_data[service] = float(data["cost"])
                 elif isinstance(data, (int, float)):
                     cost_data[service] = float(data)
-        
-        if 'total_cost' in runbooks_data:
-            cost_data['total'] = float(runbooks_data['total_cost'])
-            
+
+        if "total_cost" in runbooks_data:
+            cost_data["total"] = float(runbooks_data["total_cost"])
+
         return cost_data
-    
+
     def _fetch_aws_cost_data(
-        self, 
-        aws_profile: Optional[str], 
-        time_period: Optional[Dict[str, str]]
+        self, aws_profile: Optional[str], time_period: Optional[Dict[str, str]]
     ) -> Dict[str, float]:
         """
         Fetch real cost data from AWS Cost Explorer API.
-        
-        Note: This is a simulation for the framework. Real implementation 
+
+        Note: This is a simulation for the framework. Real implementation
         would use boto3 Cost Explorer client.
         """
         # Real AWS Cost Explorer data integration
         # Real implementation would make actual API calls
         aws_cost_data = {
-            'EC2-Instance': 145.67,
-            'S3': 23.45, 
-            'RDS': 89.12,
-            'Lambda': 12.34,
-            'CloudWatch': 8.90,
-            'total': 279.48
+            "EC2-Instance": 145.67,
+            "S3": 23.45,
+            "RDS": 89.12,
+            "Lambda": 12.34,
+            "CloudWatch": 8.90,
+            "total": 279.48,
         }
-        
+
         return aws_cost_data
-    
+
     def _fetch_aws_resource_data(
-        self,
-        aws_profile: Optional[str],
-        resource_types: Optional[List[str]]
+        self, aws_profile: Optional[str], resource_types: Optional[List[str]]
     ) -> Dict[str, Any]:
         """
         Fetch real resource data from AWS APIs.
-        
+
         Simulated implementation - real version would use boto3.
         """
         # Real AWS API resource data integration
         aws_resource_data = {
-            'ec2_instances': {'count': 15, 'running': 12, 'stopped': 3},
-            's3_buckets': {'count': 8, 'encrypted': 7, 'public': 1},
-            'rds_instances': {'count': 4, 'multi_az': 2, 'encrypted': 4}
+            "ec2_instances": {"count": 15, "running": 12, "stopped": 3},
+            "s3_buckets": {"count": 8, "encrypted": 7, "public": 1},
+            "rds_instances": {"count": 4, "multi_az": 2, "encrypted": 4},
         }
-        
+
         return aws_resource_data
-    
-    def _compare_cost_data(
-        self, 
-        runbooks_costs: Dict[str, float], 
-        aws_costs: Dict[str, float]
-    ) -> Dict[str, Any]:
+
+    def _compare_cost_data(self, runbooks_costs: Dict[str, float], aws_costs: Dict[str, float]) -> Dict[str, Any]:
         """Compare cost data between runbooks and AWS APIs."""
-        
-        comparison_result = {
-            "comparisons": [],
-            "discrepancies_count": 0,
-            "total_variance": 0.0,
-            "accuracy_score": 0.0
-        }
-        
+
+        comparison_result = {"comparisons": [], "discrepancies_count": 0, "total_variance": 0.0, "accuracy_score": 0.0}
+
         common_services = set(runbooks_costs.keys()) & set(aws_costs.keys())
-        
+
         for service in common_services:
             runbooks_cost = runbooks_costs[service]
             aws_cost = aws_costs[service]
-            
+
             variance = abs(runbooks_cost - aws_cost)
             variance_percentage = (variance / max(aws_cost, 0.01)) * 100
-            
+
             comparison = {
                 "service": service,
                 "runbooks_cost": runbooks_cost,
                 "aws_cost": aws_cost,
                 "variance": variance,
                 "variance_percentage": variance_percentage,
-                "within_tolerance": variance_percentage <= 5.0  # 5% tolerance
+                "within_tolerance": variance_percentage <= 5.0,  # 5% tolerance
             }
-            
+
             comparison_result["comparisons"].append(comparison)
-            
+
             if not comparison["within_tolerance"]:
                 comparison_result["discrepancies_count"] += 1
-            
+
             comparison_result["total_variance"] += variance
-        
+
         return comparison_result
-    
+
     def _compare_resource_data(
-        self,
-        runbooks_resources: Dict[str, Any],
-        aws_resources: Dict[str, Any]
+        self, runbooks_resources: Dict[str, Any], aws_resources: Dict[str, Any]
     ) -> Dict[str, Any]:
         """Compare resource data between runbooks and AWS APIs."""
-        
-        comparison_result = {
-            "resource_comparisons": [],
-            "resource_discrepancies": 0,
-            "accuracy_score": 0.0
-        }
-        
+
+        comparison_result = {"resource_comparisons": [], "resource_discrepancies": 0, "accuracy_score": 0.0}
+
         # Calculate accuracy based on actual data comparison
         if runbooks_data and mcp_data:
             # Calculate accuracy based on data consistency
-            runbooks_total = sum(float(v) for v in runbooks_data.values() if isinstance(v, (int, float, str)) and str(v).replace('.', '').isdigit())
-            mcp_total = sum(float(v) for v in mcp_data.values() if isinstance(v, (int, float, str)) and str(v).replace('.', '').isdigit())
+            runbooks_total = sum(
+                float(v)
+                for v in runbooks_data.values()
+                if isinstance(v, (int, float, str)) and str(v).replace(".", "").isdigit()
+            )
+            mcp_total = sum(
+                float(v)
+                for v in mcp_data.values()
+                if isinstance(v, (int, float, str)) and str(v).replace(".", "").isdigit()
+            )
 
             if mcp_total > 0:
                 accuracy_ratio = min(runbooks_total / mcp_total, mcp_total / runbooks_total)
@@ -538,30 +538,30 @@ class MCPValidator:
                 comparison_result["accuracy_score"] = 0.0
         else:
             comparison_result["accuracy_score"] = 0.0
-        
+
         return comparison_result
-    
+
     def _calculate_accuracy_percentage(self, comparison_result: Dict[str, Any]) -> float:
         """Calculate overall accuracy percentage from comparison results."""
-        
+
         comparisons = comparison_result.get("comparisons", [])
         if not comparisons:
             return 0.0
-        
+
         accurate_comparisons = len([c for c in comparisons if c.get("within_tolerance", False)])
         accuracy_percentage = (accurate_comparisons / len(comparisons)) * 100
-        
+
         return accuracy_percentage
-    
+
     def _calculate_resource_accuracy(self, comparison_result: Dict[str, Any]) -> float:
         """Calculate resource discovery accuracy."""
         return comparison_result.get("accuracy_score", 0.0)
-    
+
     def _calculate_confidence_score(self, comparison_result: Dict[str, Any]) -> float:
         """Calculate confidence score based on validation quality."""
         accuracy = comparison_result.get("accuracy_score", 0.0)
         return min(accuracy / 100.0, 1.0)
-    
+
     def _determine_validation_status(self, accuracy_percentage: float) -> ValidationStatus:
         """Determine validation status based on accuracy."""
         if accuracy_percentage >= self.accuracy_threshold:
@@ -570,123 +570,122 @@ class MCPValidator:
             return ValidationStatus.WARNING
         else:
             return ValidationStatus.FAILED
-    
+
     def _assess_business_impact(
-        self,
-        accuracy_percentage: float,
-        comparison_result: Dict[str, Any],
-        validation_metrics: ValidationMetrics
+        self, accuracy_percentage: float, comparison_result: Dict[str, Any], validation_metrics: ValidationMetrics
     ) -> Dict[str, Any]:
         """Assess business impact of validation results."""
-        
+
         return {
             "financial_confidence": f"{accuracy_percentage:.1f}% cost calculation accuracy",
             "decision_reliability": "High" if accuracy_percentage >= self.accuracy_threshold else "Medium",
             "enterprise_compliance": accuracy_percentage >= self.accuracy_threshold,
             "operational_impact": f"Validation completed in {validation_metrics.execution_time_seconds:.1f}s",
-            "business_value": "Validated accuracy enables confident financial decisions"
+            "business_value": "Validated accuracy enables confident financial decisions",
         }
-    
+
     def _assess_quality_gates(self, validation_metrics: ValidationMetrics) -> Dict[str, bool]:
         """Assess quality gates based on validation metrics."""
-        
+
         return {
             "accuracy_gate": validation_metrics.accuracy_percentage >= self.accuracy_threshold,
-            "performance_gate": validation_metrics.execution_time_seconds <= self.performance_targets["max_validation_time_seconds"],
+            "performance_gate": validation_metrics.execution_time_seconds
+            <= self.performance_targets["max_validation_time_seconds"],
             "confidence_gate": validation_metrics.confidence_score >= self.performance_targets["min_confidence_score"],
-            "discrepancy_gate": (validation_metrics.discrepancies_found / max(validation_metrics.records_validated, 1)) <= (self.performance_targets["max_discrepancy_rate"] / 100)
+            "discrepancy_gate": (validation_metrics.discrepancies_found / max(validation_metrics.records_validated, 1))
+            <= (self.performance_targets["max_discrepancy_rate"] / 100),
         }
-    
+
     def _generate_recommendations(
-        self,
-        accuracy_percentage: float,
-        validation_metrics: ValidationMetrics,
-        comparison_result: Dict[str, Any]
+        self, accuracy_percentage: float, validation_metrics: ValidationMetrics, comparison_result: Dict[str, Any]
     ) -> List[str]:
         """Generate recommendations based on validation results."""
-        
+
         recommendations = []
-        
+
         if accuracy_percentage >= self.accuracy_threshold:
-            recommendations.append(f"✅ Validation passed: {accuracy_percentage:.2f}% accuracy meets {self.accuracy_threshold}% threshold")
+            recommendations.append(
+                f"✅ Validation passed: {accuracy_percentage:.2f}% accuracy meets {self.accuracy_threshold}% threshold"
+            )
         else:
-            recommendations.append(f"⚠️  Accuracy improvement needed: {accuracy_percentage:.2f}% below {self.accuracy_threshold}% threshold")
+            recommendations.append(
+                f"⚠️  Accuracy improvement needed: {accuracy_percentage:.2f}% below {self.accuracy_threshold}% threshold"
+            )
             recommendations.append("Review data collection methods and AWS API alignment")
-        
+
         if validation_metrics.execution_time_seconds > self.performance_targets["max_validation_time_seconds"]:
-            recommendations.append(f"⚡ Performance optimization needed: {validation_metrics.execution_time_seconds:.1f}s exceeds {self.performance_targets['max_validation_time_seconds']}s target")
-        
+            recommendations.append(
+                f"⚡ Performance optimization needed: {validation_metrics.execution_time_seconds:.1f}s exceeds {self.performance_targets['max_validation_time_seconds']}s target"
+            )
+
         if validation_metrics.discrepancies_found > 0:
-            recommendations.append(f"🔍 Investigate {validation_metrics.discrepancies_found} discrepancies for accuracy improvement")
-        
+            recommendations.append(
+                f"🔍 Investigate {validation_metrics.discrepancies_found} discrepancies for accuracy improvement"
+            )
+
         return recommendations
-    
+
     def _validate_recommendations(
-        self,
-        recommendations_data: Dict[str, Any],
-        aws_profile: Optional[str]
+        self, recommendations_data: Dict[str, Any], aws_profile: Optional[str]
     ) -> Dict[str, Any]:
         """Validate optimization recommendations against current AWS state."""
-        
+
         # Real validation of optimization recommendations
         return {
             "accuracy": 98.5,
             "recommendations_count": recommendations_data.get("count", 10),
             "invalid_recommendations": 1,
-            "validation_method": "Current state verification against AWS APIs"
+            "validation_method": "Current state verification against AWS APIs",
         }
-    
+
     def _generate_evidence_artifacts(
         self,
         validation_id: str,
         comparison_result: Dict[str, Any],
         runbooks_data: Dict[str, Any],
-        aws_data: Dict[str, Any]
+        aws_data: Dict[str, Any],
     ) -> List[str]:
         """Generate evidence artifacts for audit trail."""
-        
+
         artifacts = []
-        
+
         if self.evidence_collection:
             # Create evidence directory
             evidence_dir = f"./tmp/mcp_validation_evidence/{validation_id}"
             os.makedirs(evidence_dir, exist_ok=True)
-            
+
             # Save comparison results
             comparison_file = f"{evidence_dir}/comparison_results.json"
-            with open(comparison_file, 'w') as f:
+            with open(comparison_file, "w") as f:
                 json.dump(comparison_result, f, indent=2, default=str)
             artifacts.append(comparison_file)
-            
+
             # Save raw data
             raw_data_file = f"{evidence_dir}/raw_data.json"
-            with open(raw_data_file, 'w') as f:
-                json.dump({
-                    "runbooks_data": runbooks_data,
-                    "aws_data": aws_data,
-                    "timestamp": datetime.now().isoformat()
-                }, f, indent=2, default=str)
+            with open(raw_data_file, "w") as f:
+                json.dump(
+                    {"runbooks_data": runbooks_data, "aws_data": aws_data, "timestamp": datetime.now().isoformat()},
+                    f,
+                    indent=2,
+                    default=str,
+                )
             artifacts.append(raw_data_file)
-        
+
         return artifacts
-    
+
     def _generate_validation_id(self, operation_name: str) -> str:
         """Generate unique validation ID."""
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         hash_input = f"{operation_name}_{timestamp}_{self.accuracy_threshold}"
         hash_suffix = hashlib.md5(hash_input.encode()).hexdigest()[:8]
-        
+
         return f"mcp_val_{operation_name}_{timestamp}_{hash_suffix}"
-    
+
     def _create_validation_error(
-        self,
-        validation_id: str,
-        operation_name: str,
-        error_message: str,
-        execution_time: float
+        self, validation_id: str, operation_name: str, error_message: str, execution_time: float
     ) -> MCPValidationResult:
         """Create error result for failed validations."""
-        
+
         validation_metrics = ValidationMetrics(
             validation_id=validation_id,
             operation_name=operation_name,
@@ -695,9 +694,9 @@ class MCPValidator:
             execution_time_seconds=execution_time,
             records_validated=0,
             discrepancies_found=1,
-            confidence_score=0.0
+            confidence_score=0.0,
         )
-        
+
         return MCPValidationResult(
             validation_metrics=validation_metrics,
             business_impact={"error": error_message},
@@ -706,60 +705,55 @@ class MCPValidator:
             recommendations=[f"Resolve validation error: {error_message}"],
             quality_gates_status={"error_gate": False},
             raw_comparison_data={"error": error_message},
-            validation_evidence={}
+            validation_evidence={},
         )
 
 
-def create_enterprise_validator(
-    accuracy_threshold: float = 99.5,
-    evidence_collection: bool = True
-) -> MCPValidator:
+def create_enterprise_validator(accuracy_threshold: float = 99.5, evidence_collection: bool = True) -> MCPValidator:
     """
     Factory function to create enterprise MCP validator.
-    
+
     Args:
         accuracy_threshold: Minimum accuracy percentage (default 99.5%)
         evidence_collection: Enable evidence collection
-        
+
     Returns:
         Configured MCP validator instance
     """
     return MCPValidator(
         accuracy_threshold=accuracy_threshold,
         validation_scope=ValidationScope.ACCOUNT_WIDE,
-        evidence_collection=evidence_collection
+        evidence_collection=evidence_collection,
     )
 
 
 def main():
     """Demo MCP validation framework."""
-    
+
     print_header("MCP Validation Framework Demo", "latest version")
-    
+
     # Create validator
     validator = create_enterprise_validator(accuracy_threshold=99.5)
-    
+
     # Demo cost validation
     demo_runbooks_data = {
-        'services': {
-            'EC2-Instance': {'cost': 145.50},
-            'S3': {'cost': 23.40},
-            'RDS': {'cost': 89.00}
-        },
-        'total_cost': 257.90
+        "services": {"EC2-Instance": {"cost": 145.50}, "S3": {"cost": 23.40}, "RDS": {"cost": 89.00}},
+        "total_cost": 257.90,
     }
-    
+
     validation_result = validator.validate_cost_analysis(demo_runbooks_data)
-    
+
     print_success(f"Demo Validation Complete: {validation_result.validation_metrics.accuracy_percentage:.2f}% accuracy")
-    print_success(f"Quality Gates: {sum(validation_result.quality_gates_status.values())}/{len(validation_result.quality_gates_status)} passed")
-    
+    print_success(
+        f"Quality Gates: {sum(validation_result.quality_gates_status.values())}/{len(validation_result.quality_gates_status)} passed"
+    )
+
     # Generate summary
     summary = validator.generate_validation_summary()
     print_success(f"Validation Summary: {summary['performance_metrics']['average_accuracy']} average accuracy")
-    
+
     return validation_result
 
 
 if __name__ == "__main__":
-    main()
+    main()