runbooks 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

runbooks/finops/finops_dashboard.py

@@ -22,7 +22,8 @@ AWS_AVAILABLE = True
 
 def get_aws_profiles() -> List[str]:
     """Stub implementation - use dashboard_runner.py instead."""
-    return ["default", "ams-admin-Billing-ReadOnlyAccess-909135376185"]
+    import os
+    return ["default", os.getenv("BILLING_PROFILE", "default-billing-profile")]
 
 
 def get_account_id(profile: str = "default") -> str:
@@ -46,10 +47,10 @@ class FinOpsConfig:
     include_budget_data: bool = True
     include_resource_analysis: bool = True
     
-    # Legacy compatibility properties with environment variable support
-    billing_profile: str = "ams-admin-Billing-ReadOnlyAccess-909135376185"
-    management_profile: str = "ams-admin-ReadOnlyAccess-909135376185"
-    operational_profile: str = "ams-centralised-ops-ReadOnlyAccess-335083429030"
+    # Legacy compatibility properties with universal environment support
+    billing_profile: str = field(default_factory=lambda: os.getenv("BILLING_PROFILE", "default-billing-profile"))
+    management_profile: str = field(default_factory=lambda: os.getenv("MANAGEMENT_PROFILE", "default-management-profile"))
+    operational_profile: str = field(default_factory=lambda: os.getenv("CENTRALISED_OPS_PROFILE", "default-ops-profile"))
     
     # Additional expected attributes from tests
     time_range_days: int = 30

runbooks/finops/finops_scenarios.py

@@ -1,18 +1,18 @@
 """
-FinOps Business Scenarios - Manager Priority Cost Optimization Framework
+FinOps Business Scenarios - Dynamic Business Case Framework
 
-Strategic Achievement: $132,720+ annual savings (380-757% above targets)
-- FinOps-24: WorkSpaces cleanup ($13,020 annual, 104% of target)
-- FinOps-23: RDS snapshots optimization ($119,700 annual, 498% of target) 
-- FinOps-25: Commvault EC2 investigation framework (methodology established)
+Strategic Achievement: Enterprise business case management with configurable scenarios
+- Dynamic scenario configuration with environment variable overrides  
+- Business-focused naming conventions replacing hardcoded JIRA references
+- Scalable template system for unlimited business case expansion
 
 This module provides business-oriented wrapper functions for executive presentations
 calling proven technical implementations from src/runbooks/remediation/ modules.
 
 Strategic Alignment:
-- "Do one thing and do it well": Business wrappers focusing on executive insights
-- "Move Fast, But Not So Fast We Crash": Proven technical implementations underneath
-- Enterprise FAANG SDLC: Evidence-based cost optimization with audit trails
+- "Do one thing and do it well": Dynamic configuration management with enterprise templates
+- "Move Fast, But Not So Fast We Crash": Proven technical implementations with configurable business cases
+- Enterprise FAANG SDLC: Evidence-based cost optimization with reusable template framework
 """
 
 import asyncio
@@ -30,6 +30,10 @@ from ..common.rich_utils import (
 )
 from ..remediation import workspaces_list, rds_snapshot_list
 from . import commvault_ec2_analysis
+from .business_case_config import (
+    get_business_case_config, get_scenario_display_name, get_scenario_savings_range,
+    format_business_achievement, migrate_legacy_scenario_reference
+)
 
 logger = logging.getLogger(__name__)
 
@@ -55,9 +59,9 @@ def create_business_scenarios_validated(profile_name: Optional[str] = None) -> D
         commvault_data = scenarios_analyzer._get_real_commvault_data()
         
         scenarios = {
-            'FinOps-24_WorkSpaces': workspaces_data,
-            'FinOps-23_RDS_Snapshots': rds_data,
-            'FinOps-25_Commvault': commvault_data,
+            'workspaces': workspaces_data,
+            'rds_snapshots': rds_data, 
+            'backup_investigation': commvault_data,
             'metadata': {
                 'generated_at': datetime.now().isoformat(),
                 'data_source': 'Real AWS APIs via runbooks',
@@ -70,29 +74,32 @@ def create_business_scenarios_validated(profile_name: Optional[str] = None) -> D
         
     except Exception as e:
         logger.error(f"Error creating validated scenarios: {e}")
-        # Return fallback business scenarios with manager's validated achievements
+        # Return fallback business scenarios using dynamic configuration
+        config = get_business_case_config()
+        workspaces_scenario = config.get_scenario('workspaces')
+        rds_scenario = config.get_scenario('rds-snapshots')
+        backup_scenario = config.get_scenario('backup-investigation')
+        
         return {
-            'FinOps-24_WorkSpaces': {
-                'title': 'WorkSpaces Cleanup - Zero Usage Detection',
-                'validated_savings': 13020,
-                'achievement_rate': 104,
-                'risk_level': 'Low'
+            'workspaces': {
+                'title': workspaces_scenario.display_name if workspaces_scenario else 'WorkSpaces Resource Optimization',
+                'savings_range': workspaces_scenario.savings_range_display if workspaces_scenario else '$12K-15K/year',
+                'risk_level': workspaces_scenario.risk_level if workspaces_scenario else 'Low'
             },
-            'FinOps-23_RDS_Snapshots': {
-                'title': 'RDS Manual Snapshots Cleanup',
-                'validated_savings': 119700,
-                'achievement_rate': 498,
-                'risk_level': 'Medium'
+            'rds_snapshots': {
+                'title': rds_scenario.display_name if rds_scenario else 'RDS Storage Optimization',
+                'savings_range': rds_scenario.savings_range_display if rds_scenario else '$5K-24K/year',
+                'risk_level': rds_scenario.risk_level if rds_scenario else 'Medium'
             },
-            'FinOps-25_Commvault': {
-                'title': 'Commvault Account Investigation',
+            'backup_investigation': {
+                'title': backup_scenario.display_name if backup_scenario else 'Backup Infrastructure Analysis',
                 'framework_status': 'Investigation Ready',
-                'risk_level': 'Medium'
+                'risk_level': backup_scenario.risk_level if backup_scenario else 'Medium'
             },
             'metadata': {
                 'generated_at': datetime.now().isoformat(),
-                'data_source': 'Manager scenarios fallback - $132,720+ validated',
-                'validation_method': 'Business case validation',
+                'data_source': 'Dynamic business case configuration',
+                'validation_method': 'Template-based business scenarios',
                 'version': '0.9.5'
             }
         }

runbooks/finops/iam_guidance.py

@@ -11,6 +11,8 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 
+from runbooks.common import get_aws_cli_example_period
+
 console = Console()
 
 
@@ -311,6 +313,9 @@ def handle_cost_explorer_error(error: Exception, profile_name: Optional[str] = N
 
 def _display_single_account_cost_explorer_guidance(error: Exception, profile_name: Optional[str] = None):
     """Display context-aware guidance for single account Cost Explorer limitations."""
+    
+    # Get dynamic date period for CLI examples
+    start_date, end_date = get_aws_cli_example_period()
 
     # Main explanation panel
     explanation_panel = Panel(
@@ -354,7 +359,7 @@ def _display_single_account_cost_explorer_guidance(error: Exception, profile_nam
         f"[green]✅ Recommended Solutions:[/green]\n\n"
         f"{solution_commands}\n\n"
         f"[bold]🎯 Quick Test Commands:[/bold]\n"
-        f"• Test billing access: `aws ce get-cost-and-usage --time-period Start=2024-01-01,End=2024-01-02 --granularity MONTHLY --metrics UnblendedCost --profile your-billing-profile`\n"
+        f"• Test billing access: `aws ce get-cost-and-usage --time-period Start={start_date},End={end_date} --granularity MONTHLY --metrics UnblendedCost --profile your-billing-profile`\n"
         f"• List available profiles: `aws configure list-profiles`\n"
         f"• Check current identity: `aws sts get-caller-identity --profile {profile_name or 'your-profile'}`\n\n"
         f"[bold]💡 Alternative Approach:[/bold]\n"

runbooks/finops/nat_gateway_optimizer.py

@@ -143,7 +143,7 @@ class NATGatewayOptimizer:
         # NAT Gateway pricing - using dynamic pricing engine
         # Base monthly cost calculation (will be applied per region)
         self._base_monthly_cost_us_east_1 = get_service_monthly_cost("nat_gateway", "us-east-1")
-        self.nat_gateway_data_processing_cost = 0.045  # $0.045/GB (data transfer pricing)
+        self.nat_gateway_data_processing_cost = get_service_monthly_cost("data_transfer", "us-east-1")  # Dynamic data transfer pricing
         
         # Enterprise thresholds for optimization recommendations
         self.low_usage_threshold_connections = 10  # Active connections per day
@@ -155,9 +155,9 @@ class NATGatewayOptimizer:
         try:
             return get_service_monthly_cost("nat_gateway", region)
         except Exception:
-            # Fallback to regional cost calculation
+            # Fallback to regional cost calculation using dynamic pricing
             from ..common.aws_pricing import calculate_regional_cost
-            return calculate_regional_cost(self._base_monthly_cost_us_east_1, region)
+            return calculate_regional_cost(self._base_monthly_cost_us_east_1, region, "nat_gateway", self.profile_name)
         
     async def analyze_nat_gateways(self, dry_run: bool = True) -> NATGatewayOptimizerResults:
         """
@@ -778,39 +778,58 @@ class EnhancedVPCCostOptimizer:
         self.cost_model = self._initialize_dynamic_cost_model()
     
     def _initialize_dynamic_cost_model(self) -> Dict[str, float]:
-        """Initialize dynamic cost model using AWS pricing engine."""
+        """Initialize dynamic cost model using AWS pricing engine with universal compatibility."""
         try:
             # Get base pricing for us-east-1, then apply regional multipliers as needed
             base_region = "us-east-1"
             
             return {
-                "nat_gateway_monthly": get_service_monthly_cost("nat_gateway", base_region),
-                "nat_gateway_data_processing": get_service_monthly_cost("data_transfer", base_region),
-                "transit_gateway_monthly": get_service_monthly_cost("transit_gateway", base_region),
-                "vpc_endpoint_monthly": get_service_monthly_cost("vpc_endpoint", base_region),
-                "data_transfer_regional": get_service_monthly_cost("data_transfer", base_region),
-                "data_transfer_internet": get_service_monthly_cost("data_transfer", base_region) * 4.5,  # Internet is ~4.5x higher
+                "nat_gateway_monthly": get_service_monthly_cost("nat_gateway", base_region, self.profile),
+                "nat_gateway_data_processing": get_service_monthly_cost("data_transfer", base_region, self.profile),
+                "transit_gateway_monthly": get_service_monthly_cost("transit_gateway", base_region, self.profile),
+                "vpc_endpoint_monthly": get_service_monthly_cost("vpc_endpoint", base_region, self.profile),
+                "vpc_endpoint_interface_hourly": get_service_monthly_cost("vpc_endpoint_interface", base_region, self.profile) / (24 * 30),
+                "transit_gateway_attachment_hourly": get_service_monthly_cost("transit_gateway_attachment", base_region, self.profile) / (24 * 30),
+                "data_transfer_regional": get_service_monthly_cost("data_transfer", base_region, self.profile),
+                "data_transfer_internet": get_service_monthly_cost("data_transfer", base_region, self.profile) * 4.5,  # Internet is ~4.5x higher
             }
         except Exception as e:
             print_warning(f"Dynamic pricing initialization failed: {e}")
-            # Fallback to regional cost calculation
-            from ..common.aws_pricing import calculate_regional_cost
-            base_costs = {
-                "nat_gateway_hourly": 0.045,
-                "nat_gateway_data_processing": 0.045,  # per GB
-                "transit_gateway_monthly": 36.50,
-                "transit_gateway_attachment_hourly": 0.05,
-                "vpc_endpoint_interface_hourly": 0.01,
-                "data_transfer_regional": 0.01,  # per GB within region
-                "data_transfer_cross_region": 0.02,  # per GB cross-region
-                "data_transfer_internet": 0.09  # per GB to internet
-            }
+            print_warning("Attempting AWS Pricing API fallback with universal profile support")
+            # Enhanced fallback with AWS Pricing API integration
+            from ..common.aws_pricing import get_aws_pricing_engine, AWSOfficialPricingEngine
             
-            # Apply regional multipliers to fallback costs
-            return {
-                key: calculate_regional_cost(value, "us-east-1") 
-                for key, value in base_costs.items()
-            }
+            try:
+                # Use AWS Pricing API with profile support for universal compatibility
+                pricing_engine = get_aws_pricing_engine(profile=self.profile, enable_fallback=True)
+                
+                # Get actual AWS pricing instead of hardcoded values
+                nat_gateway_pricing = pricing_engine.get_nat_gateway_pricing("us-east-1")
+                transit_gateway_pricing = pricing_engine.get_transit_gateway_pricing("us-east-1")
+                vpc_endpoint_pricing = pricing_engine.get_vpc_endpoint_pricing("us-east-1")
+                data_transfer_pricing = pricing_engine.get_data_transfer_pricing("us-east-1", "internet")
+                
+                return {
+                    "nat_gateway_monthly": nat_gateway_pricing.monthly_cost,
+                    "nat_gateway_data_processing": data_transfer_pricing.cost_per_gb,
+                    "transit_gateway_monthly": transit_gateway_pricing.monthly_cost,
+                    "transit_gateway_attachment_hourly": transit_gateway_pricing.attachment_hourly_cost,
+                    "vpc_endpoint_interface_hourly": vpc_endpoint_pricing.interface_hourly_cost,
+                    "data_transfer_regional": data_transfer_pricing.cost_per_gb * 0.1,  # Regional is ~10% of internet cost
+                    "data_transfer_cross_region": data_transfer_pricing.cost_per_gb * 0.2,  # Cross-region is ~20% of internet cost
+                    "data_transfer_internet": data_transfer_pricing.cost_per_gb
+                }
+                
+            except Exception as pricing_error:
+                print_error(f"ENTERPRISE COMPLIANCE VIOLATION: Cannot determine pricing without AWS API access: {pricing_error}")
+                print_warning("Universal compatibility requires dynamic pricing - hardcoded values not permitted")
+                
+                # Return error state instead of hardcoded values to maintain enterprise compliance
+                raise RuntimeError(
+                    "Universal compatibility mode requires dynamic AWS pricing API access. "
+                    "Please ensure your AWS profile has pricing:GetProducts permissions or configure "
+                    "appropriate billing/management profile access."
+                )
         
     async def analyze_comprehensive_vpc_costs(self, profile: Optional[str] = None, 
                                             regions: Optional[List[str]] = None) -> Dict[str, Any]:

runbooks/finops/notebook_utils.py

@@ -591,6 +591,6 @@ if __name__ == '__main__':
             config=config,
             optimization_focus=OptimizationCategory.COST_OPTIMIZATION
         )
-        print(f"Dashboard created with {len(result.export_files)} export files")
+        console.print(f"Dashboard created with {len(result.export_files)} export files")
     
     asyncio.run(test_dashboard())

runbooks/finops/schemas.py

@@ -26,7 +26,7 @@ from typing import Dict, List, Optional, Union, Any, Literal
 from enum import Enum
 import re
 
-from pydantic import BaseModel, Field, validator, root_validator, ConfigDict
+from pydantic import BaseModel, Field, field_validator, model_validator, ConfigDict
 from pydantic.types import UUID4, PositiveFloat, NonNegativeFloat
 
 
@@ -106,7 +106,8 @@ class CostBreakdown(BaseSchema):
     percentage_of_total: float = Field(..., ge=0, le=100)
     resource_count: int = Field(..., ge=0)
     
-    @validator('service_name')
+    @field_validator('service_name')
+    @classmethod
     def validate_service_name(cls, v):
         """Validate AWS service names."""
         # Common AWS service patterns
@@ -130,14 +131,15 @@ class CostBreakdown(BaseSchema):
         
         return v.strip()
     
-    @validator('annual_cost')
-    def validate_annual_cost_consistency(cls, v, values):
+    @field_validator('annual_cost')
+    @classmethod
+    def validate_annual_cost_consistency(cls, v, info):
         """Ensure annual cost is approximately 12x monthly cost."""
-        if 'monthly_cost' in values:
-            expected_annual = values['monthly_cost'] * 12
+        if 'monthly_cost' in info.data:
+            expected_annual = info.data['monthly_cost'] * 12
             # Allow 1% tolerance for rounding differences
             if abs(v - expected_annual) > (expected_annual * 0.01):
-                raise ValueError(f'Annual cost {v} should be approximately 12x monthly cost {values["monthly_cost"]}')
+                raise ValueError(f'Annual cost {v} should be approximately 12x monthly cost {info.data["monthly_cost"]}')
         return v
 
 
@@ -169,7 +171,8 @@ class OptimizationScenario(BaseSchema):
     validation_timestamp: Optional[datetime] = Field(None)
     mcp_variance_percent: Optional[float] = Field(None, ge=0, le=100)
     
-    @validator('scenario_name')
+    @field_validator('scenario_name')
+    @classmethod
     def validate_scenario_name(cls, v):
         """Validate scenario naming conventions."""
         # Ensure professional naming
@@ -177,27 +180,30 @@ class OptimizationScenario(BaseSchema):
             raise ValueError('Scenario name must start with capital letter and contain only letters, numbers, spaces, hyphens, and parentheses')
         return v.strip()
     
-    @validator('annual_savings')
-    def validate_annual_savings_consistency(cls, v, values):
+    @field_validator('annual_savings')
+    @classmethod
+    def validate_annual_savings_consistency(cls, v, info):
         """Ensure annual savings consistency with monthly savings."""
-        if 'monthly_savings' in values:
-            expected_annual = values['monthly_savings'] * 12
+        if 'monthly_savings' in info.data:
+            expected_annual = info.data['monthly_savings'] * 12
             if abs(v - expected_annual) > (expected_annual * 0.01):  # 1% tolerance
-                raise ValueError(f'Annual savings {v} should be approximately 12x monthly savings {values["monthly_savings"]}')
+                raise ValueError(f'Annual savings {v} should be approximately 12x monthly savings {info.data["monthly_savings"]}')
         return v
     
-    @validator('payback_period_months')
-    def calculate_payback_period(cls, v, values):
+    @field_validator('payback_period_months')
+    @classmethod
+    def calculate_payback_period(cls, v, info):
         """Calculate payback period if not provided."""
-        if v is None and 'implementation_cost' in values and 'monthly_savings' in values:
-            impl_cost = values['implementation_cost']
-            monthly_savings = values['monthly_savings']
+        if v is None and 'implementation_cost' in info.data and 'monthly_savings' in info.data:
+            impl_cost = info.data['implementation_cost']
+            monthly_savings = info.data['monthly_savings']
             if monthly_savings > 0:
                 calculated_payback = impl_cost / monthly_savings
                 return round(calculated_payback, 1)
         return v
     
-    @validator('affected_services')
+    @field_validator('affected_services')
+    @classmethod
     def validate_aws_services(cls, v):
         """Validate AWS service names in affected services."""
         common_services = {
@@ -215,7 +221,8 @@ class OptimizationScenario(BaseSchema):
         
         return v
     
-    @validator('affected_accounts')
+    @field_validator('affected_accounts')
+    @classmethod
     def validate_account_ids(cls, v):
         """Validate AWS account ID format."""
         account_pattern = r'^\d{12}$|^[\w\-\.]{1,50}$'  # 12-digit ID or account name
@@ -270,47 +277,50 @@ class CostOptimizationResult(BaseSchema):
         default=[ExportFormat.JSON, ExportFormat.CSV, ExportFormat.PDF]
     )
     
-    @validator('total_potential_annual_savings')
-    def validate_annual_consistency(cls, v, values):
+    @field_validator('total_potential_annual_savings')
+    @classmethod
+    def validate_annual_consistency(cls, v, info):
         """Validate annual savings consistency."""
-        if 'total_potential_monthly_savings' in values:
-            expected = values['total_potential_monthly_savings'] * 12
+        if 'total_potential_monthly_savings' in info.data:
+            expected = info.data['total_potential_monthly_savings'] * 12
             if abs(v - expected) > (expected * 0.01):
                 raise ValueError('Annual savings must be approximately 12x monthly savings')
         return v
     
-    @validator('savings_percentage')
-    def calculate_savings_percentage(cls, v, values):
+    @field_validator('savings_percentage')
+    @classmethod
+    def calculate_savings_percentage(cls, v, info):
         """Validate or calculate savings percentage."""
-        if 'current_monthly_spend' in values and 'total_potential_monthly_savings' in values:
-            current_spend = values['current_monthly_spend']
+        if 'current_monthly_spend' in info.data and 'total_potential_monthly_savings' in info.data:
+            current_spend = info.data['current_monthly_spend']
             if current_spend > 0:
-                calculated = (values['total_potential_monthly_savings'] / current_spend) * 100
+                calculated = (info.data['total_potential_monthly_savings'] / current_spend) * 100
                 if abs(v - calculated) > 0.1:  # 0.1% tolerance
                     raise ValueError(f'Savings percentage {v}% inconsistent with calculated {calculated:.1f}%')
         return v
     
-    @validator('total_scenarios')
-    def validate_scenario_count(cls, v, values):
+    @field_validator('total_scenarios')
+    @classmethod
+    def validate_scenario_count(cls, v, info):
         """Ensure scenario count matches actual scenarios."""
-        if 'optimization_scenarios' in values:
-            actual_count = len(values['optimization_scenarios'])
+        if 'optimization_scenarios' in info.data:
+            actual_count = len(info.data['optimization_scenarios'])
             if v != actual_count:
                 raise ValueError(f'Total scenarios {v} does not match actual scenarios count {actual_count}')
         return v
     
-    @root_validator
-    def validate_complexity_distribution(cls, values):
+    @model_validator(mode='after')
+    def validate_complexity_distribution(self):
         """Validate complexity scenario counts."""
-        scenarios = values.get('optimization_scenarios', [])
+        scenarios = self.optimization_scenarios or []
         if scenarios:
             low_count = sum(1 for s in scenarios if s.complexity == ComplexityLevel.LOW)
             medium_count = sum(1 for s in scenarios if s.complexity == ComplexityLevel.MEDIUM)
             high_count = sum(1 for s in scenarios if s.complexity == ComplexityLevel.HIGH)
             
-            expected_low = values.get('low_complexity_scenarios', 0)
-            expected_medium = values.get('medium_complexity_scenarios', 0)
-            expected_high = values.get('high_complexity_scenarios', 0)
+            expected_low = self.low_complexity_scenarios or 0
+            expected_medium = self.medium_complexity_scenarios or 0
+            expected_high = self.high_complexity_scenarios or 0
             
             if (low_count != expected_low or 
                 medium_count != expected_medium or 
@@ -320,7 +330,7 @@ class CostOptimizationResult(BaseSchema):
                     f'actual L:{low_count} M:{medium_count} H:{high_count}'
                 )
         
-        return values
+        return self
 
 
 # Business Interface Schemas
@@ -350,7 +360,8 @@ class ExecutiveSummary(BaseSchema):
     data_validation_status: ValidationStatus = Field(...)
     last_validated: datetime = Field(...)
     
-    @validator('roi_percentage')
+    @field_validator('roi_percentage')
+    @classmethod
     def validate_reasonable_roi(cls, v):
         """Ensure ROI is reasonable for executive presentation."""
         if v > 1000:  # 1000% ROI
@@ -377,12 +388,13 @@ class MCPValidationResult(BaseSchema):
     mcp_source: str = Field(..., min_length=1)
     response_time_seconds: Optional[PositiveFloat] = Field(None, le=300)  # 5 minute timeout
     
-    @validator('variance_percent')
-    def calculate_variance_percent(cls, v, values):
+    @field_validator('variance_percent')
+    @classmethod
+    def calculate_variance_percent(cls, v, info):
         """Calculate and validate variance percentage."""
-        if 'notebook_value' in values and 'mcp_value' in values:
-            notebook_val = values['notebook_value']
-            mcp_val = values['mcp_value']
+        if 'notebook_value' in info.data and 'mcp_value' in info.data:
+            notebook_val = info.data['notebook_value']
+            mcp_val = info.data['mcp_value']
             
             if notebook_val > 0:
                 calculated = abs((notebook_val - mcp_val) / notebook_val) * 100
@@ -441,22 +453,24 @@ class ComprehensiveTestSuite(BaseSchema):
     meets_production_criteria: bool = Field(...)
     quality_score: float = Field(..., ge=0, le=100)
     
-    @validator('passed_tests')
-    def validate_test_counts(cls, v, values):
+    @field_validator('passed_tests')
+    @classmethod
+    def validate_test_counts(cls, v, info):
         """Ensure test counts are consistent."""
-        if 'failed_tests' in values and 'skipped_tests' in values and 'total_tests' in values:
-            calculated_total = v + values['failed_tests'] + values['skipped_tests']
-            if calculated_total != values['total_tests']:
-                raise ValueError(f'Test counts inconsistent: {calculated_total} ≠ {values["total_tests"]}')
+        if 'failed_tests' in info.data and 'skipped_tests' in info.data and 'total_tests' in info.data:
+            calculated_total = v + info.data['failed_tests'] + info.data['skipped_tests']
+            if calculated_total != info.data['total_tests']:
+                raise ValueError(f'Test counts inconsistent: {calculated_total} ≠ {info.data["total_tests"]}')
         return v
     
-    @validator('pass_rate_percent')
-    def calculate_pass_rate(cls, v, values):
+    @field_validator('pass_rate_percent')
+    @classmethod
+    def calculate_pass_rate(cls, v, info):
         """Calculate and validate pass rate."""
-        if 'passed_tests' in values and 'total_tests' in values:
-            total = values['total_tests']
+        if 'passed_tests' in info.data and 'total_tests' in info.data:
+            total = info.data['total_tests']
             if total > 0:
-                calculated = (values['passed_tests'] / total) * 100
+                calculated = (info.data['passed_tests'] / total) * 100
                 if abs(v - calculated) > 0.01:
                     raise ValueError(f'Pass rate {v}% inconsistent with calculated {calculated:.2f}%')
         return v
@@ -480,7 +494,8 @@ class ExportMetadata(BaseSchema):
     export_validated: bool = Field(...)
     validation_errors: List[str] = Field(default_factory=list)
     
-    @validator('file_path')
+    @field_validator('file_path')
+    @classmethod
     def validate_file_path(cls, v):
         """Validate file path format."""
         # Basic path validation

runbooks/finops/single_dashboard.py

@@ -346,18 +346,34 @@ class SingleAccountDashboard:
             # Integrate quarterly data into trend data structure
             corrected_trend_data["quarterly_costs_by_service"] = quarterly_costs
             
-            # Log the trend analysis context for transparency
+            # Enhanced trend analysis context with MCP validation awareness
             if "period_metadata" in corrected_trend_data:
                 metadata = corrected_trend_data["period_metadata"]
                 current_days = metadata.get("current_days", 0)
                 previous_days = metadata.get("previous_days", 0)
+                days_difference = metadata.get("days_difference", abs(current_days - previous_days))
                 reliability = metadata.get("trend_reliability", "unknown")
+                alignment_strategy = metadata.get("period_alignment_strategy", "standard")
                 
+                # ENHANCED LOGIC: Reduce warnings when using intelligent period alignment
                 if metadata.get("is_partial_comparison", False):
-                    print_warning(f"Partial period comparison detected: {current_days} vs {previous_days} days")
-                    print_info(f"Trend reliability: {reliability}")
+                    if alignment_strategy == "equal_days":
+                        # Equal-day comparison reduces the severity of partial period concerns
+                        print_info(f"🔄 Enhanced period alignment: {current_days} vs {previous_days} days (equal-day strategy)")
+                        if reliability in ["high", "medium_with_validation_support"]:
+                            print_success(f"✅ Trend reliability: {reliability} (enhanced alignment)")
+                        else:
+                            print_info(f"Trend reliability: {reliability}")
+                    else:
+                        # Standard partial period warning for traditional comparisons
+                        print_warning(f"⚠️ Partial period comparison: {current_days} vs {previous_days} days")
+                        print_info(f"Trend reliability: {reliability}")
+                        
+                    # Add context for very small differences
+                    if days_difference <= 5:
+                        print_info(f"💡 Small period difference ({days_difference} days) - trends should be reliable")
                 else:
-                    print_success(f"Equal period comparison: {current_days} vs {previous_days} days")
+                    print_success(f"✅ Equal period comparison: {current_days} vs {previous_days} days")
             
             return corrected_trend_data
             

runbooks/finops/tests/test_integration.py

@@ -34,6 +34,8 @@ try:
     except ImportError:
         # Define mock_costexplorer as a no-op decorator for compatibility
         def mock_costexplorer(func):
+    # Dynamic test period for consistent test data
+    test_period = get_test_date_period(30)
             def wrapper(*args, **kwargs):
                 return func(*args, **kwargs)
 
@@ -128,7 +130,7 @@ class TestAWSIntegrationWithMoto:
         mock_cost_data = {
             "ResultsByTime": [
                 {
-                    "TimePeriod": {"Start": "2024-01-01", "End": "2024-01-31"},
+                    "TimePeriod": {"Start": test_period["Start"], "End": test_period["End"]},
                     "Total": {"UnblendedCost": {"Amount": "50000.00", "Unit": "USD"}},
                     "Groups": [
                         {"Keys": ["EC2-Instance"], "Metrics": {"UnblendedCost": {"Amount": "20000.00", "Unit": "USD"}}},

runbooks/finops/vpc_cleanup_exporter.py

@@ -16,6 +16,7 @@ from datetime import datetime
 from typing import Any, Dict, List
 
 from .markdown_exporter import MarkdownExporter
+from runbooks.common.rich_utils import console
 
 
 def _format_tags_for_display(tags_dict: Dict[str, str]) -> str:
@@ -76,7 +77,7 @@ def export_vpc_cleanup_results(vpc_result: Any, export_formats: List[str], outpu
             )
             results['markdown'] = markdown_filename
         except Exception as e:
-            print(f"Warning: Markdown export failed: {e}")
+            console.print(f"[yellow]Warning: Markdown export failed: {e}[/yellow]")
             results['markdown'] = None
     
     # Real implementations for other formats