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

runbooks/finops/__init__.py

@@ -67,7 +67,7 @@ from runbooks.finops.finops_scenarios import (
     FinOpsBusinessScenarios,
 )
 
-# NEW v0.9.5: Clean API wrapper for notebook consumption
+# NEW latest version: Clean API wrapper for notebook consumption
 from runbooks.finops.scenarios import (
     finops_workspaces,
     finops_snapshots,
@@ -99,12 +99,12 @@ __all__ = [
     "_run_executive_dashboard",
     # Enterprise Dashboard Classes - backward compatibility
     "FinOpsConfig",
-    # Business scenarios with notebook integration (v0.9.5)
+    # Business scenarios with notebook integration (latest version)
     "create_business_scenarios_validated",
     "format_for_business_audience",
     "format_for_technical_audience",
     "FinOpsBusinessScenarios",
-    # NEW v0.9.5: Clean API wrapper functions (cleaned naming)
+    # NEW latest version: Clean API wrapper functions (cleaned naming)
     "finops_workspaces",
     "finops_snapshots",
     "finops_commvault",
@@ -140,7 +140,7 @@ __all__ = [
     "export_audit_report_to_json",
     "export_trend_data_to_json",
     "load_config_file",
-    # NOTEBOOK INTEGRATION FUNCTIONS (v0.9.5)
+    # NOTEBOOK INTEGRATION FUNCTIONS (latest version)
     "format_currency",
     "create_business_summary_table", 
     "export_scenarios_to_notebook_html",

runbooks/finops/business_cases.py

@@ -1,5 +1,5 @@
 """
-🏢 CloudOps-Automation Business Cases Module (Enhanced v0.9.6)
+🏢 CloudOps-Automation Business Cases Module (Enhanced latest version)
 Enterprise Business Logic Extraction from 67+ Notebooks
 
 Strategic Achievement: Business logic consolidation enabling $78,500+ annual savings 
@@ -17,7 +17,7 @@ Enhanced Features:
 - Executive dashboard integration
 
 Author: Enterprise Agile Team (6-Agent Coordination)
-Version: 0.9.6 - Distributed Architecture Framework
+Version: latest version - Distributed Architecture Framework
 """
 
 import os
@@ -758,7 +758,7 @@ class EnhancedBusinessCaseDashboard:
         
         Strategic Output: Complete business case portfolio for C-suite presentation
         """
-        print_header("Enterprise Business Case Portfolio Analysis", "v0.9.6") 
+        print_header("Enterprise Business Case Portfolio Analysis", "latest version") 
         
         # Get FinOps business cases (Universal $132K methodology)
         finops_cases = self.finops_analyzer.get_all_business_cases()

runbooks/finops/cli.py

@@ -228,7 +228,7 @@ def main() -> int:
     parser.add_argument(
         "--scenario",
         type=str,
-        help="Business scenario analysis (workspaces, snapshots, commvault, nat-gateway, elastic-ip, ebs, vpc-cleanup)",
+        help="Business scenario analysis (workspaces, rds-snapshots, backup-investigation, nat-gateway, elastic-ip, ebs-optimization, vpc-cleanup)",
     )
     parser.add_argument(
         "--help-scenario",
@@ -272,93 +272,58 @@ def main() -> int:
 
             console.print(f"[bold cyan]🎯 Executing Business Scenario: {args.scenario}[/bold cyan]")
 
-            # Define scenario execution functions with proper parameters
-            # CRITICAL FIX: Use enterprise profile management for proper BILLING_PROFILE fallback
-            from runbooks.common.profile_utils import get_profile_for_operation
-
-            def execute_workspaces_scenario():
-                from runbooks.finops.scenarios import finops_workspaces
-                # Use enterprise profile resolution: User > Environment > Default
-                profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
-                return finops_workspaces(profile=profile_param)
-
-            def execute_snapshots_scenario():
-                from runbooks.finops.scenarios import finops_snapshots
-                # Use enterprise profile resolution: User > Environment > Default
-                profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
-                return finops_snapshots(profile=profile_param)
-
-            def execute_commvault_scenario():
-                from runbooks.finops.scenarios import finops_commvault
-                # Use enterprise profile resolution: User > Environment > Default
-                profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
-                return finops_commvault(profile=profile_param)
-
-            def execute_nat_gateway_scenario():
-                from runbooks.finops.nat_gateway_optimizer import nat_gateway_optimizer
-                # Use enterprise profile resolution: User > Environment > Default
-                profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
-                regions = args.regions if args.regions else ['us-east-1']
-                # Call the CLI function with default parameters
-                nat_gateway_optimizer(
-                    profile=profile_param,
-                    regions=regions,
-                    dry_run=True,
-                    export_format='json',
-                    output_file=None,
-                    usage_threshold_days=7
-                )
-                return {"scenario": "nat-gateway", "status": "completed", "profile": profile_param}
-
-            def execute_ebs_scenario():
-                # Create a simplified EBS scenario execution
-                print_info("EBS optimization scenario analysis")
-                # Use enterprise profile resolution: User > Environment > Default
-                profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
-                return {"scenario": "ebs", "status": "completed", "profile": profile_param}
-
-            def execute_vpc_cleanup_scenario():
-                # Create a simplified VPC cleanup scenario execution
-                print_info("VPC cleanup scenario analysis")
-                # Use enterprise profile resolution: User > Environment > Default
-                profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
-                return {"scenario": "vpc-cleanup", "status": "completed", "profile": profile_param}
-
-            def execute_elastic_ip_scenario():
-                # Create a simplified elastic IP scenario execution
-                print_info("Elastic IP optimization scenario analysis")
-                # Use enterprise profile resolution: User > Environment > Default
-                profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
-                return {"scenario": "elastic-ip", "status": "completed", "profile": profile_param}
-
-            # Map scenarios to execution functions
-            scenario_map = {
-                'workspaces': execute_workspaces_scenario,
-                'snapshots': execute_snapshots_scenario,
-                'commvault': execute_commvault_scenario,
-                'nat-gateway': execute_nat_gateway_scenario,
-                'ebs': execute_ebs_scenario,
-                'vpc-cleanup': execute_vpc_cleanup_scenario,
-                'elastic-ip': execute_elastic_ip_scenario,
-            }
-
-            if args.scenario not in scenario_map:
-                print_error(f"Unknown scenario: '{args.scenario}'")
-                print_info("Available scenarios: " + ", ".join(scenario_map.keys()))
-                return 1
-
-            # Execute scenario
-            scenario_func = scenario_map[args.scenario]
-            result = scenario_func()
-
-            print_success(f"✅ Scenario '{args.scenario}' completed successfully")
-
-            # Export results if requested
-            if args.report_type and result:
-                from runbooks.finops.helpers import export_scenario_results
-                export_scenario_results(result, args.scenario, args.report_type, args.dir)
-
-            return 0
+            # CRITICAL FIX: Handle --all flag for scenarios by using dashboard router logic
+            if hasattr(args, "all") and args.all:
+                print_info("🔍 --all flag detected: Integrating with dashboard router for organization discovery")
+
+                # Use dashboard router to handle --all flag and get profiles
+                from runbooks.finops.dashboard_router import create_dashboard_router
+                router = create_dashboard_router()
+                use_case, routing_config = router.detect_use_case(args)
+
+                # Extract profiles from routing config
+                profiles_to_use = routing_config.get("profiles_to_analyze", [])
+                if not profiles_to_use:
+                    print_error("--all flag failed to discover any profiles")
+                    return 1
+
+                print_success(f"Discovered {len(profiles_to_use)} profiles for scenario execution")
+
+                # Execute scenario across all discovered profiles
+                all_results = []
+                for profile in profiles_to_use:
+                    print_info(f"Executing scenario '{args.scenario}' for profile: {profile}")
+
+                    # Create a copy of args with single profile for execution
+                    single_profile_args = argparse.Namespace(**vars(args))
+                    single_profile_args.profiles = [profile]
+                    single_profile_args.all = False  # Disable --all for individual execution
+
+                    # Execute scenario with single profile (recursive call but with all=False)
+                    result = _execute_single_scenario(single_profile_args)
+                    if result:
+                        all_results.append(result)
+
+                # Combine results and export if requested
+                combined_result = {
+                    "scenario": args.scenario,
+                    "status": "completed",
+                    "profiles_analyzed": len(profiles_to_use),
+                    "individual_results": all_results,
+                    "organization_scope": use_case == "organization_wide"
+                }
+
+                print_success(f"✅ Scenario '{args.scenario}' completed for {len(profiles_to_use)} profiles")
+
+                # Export results if requested
+                if args.report_type and combined_result:
+                    from runbooks.finops.helpers import export_scenario_results
+                    export_scenario_results(combined_result, args.scenario, args.report_type, args.dir)
+
+                return 0
+            else:
+                # Handle single profile execution (existing logic)
+                return _execute_single_scenario(args)
 
         except ImportError as e:
             console.print(f"[red]❌ Scenario '{args.scenario}' not available: {e}[/red]")
@@ -367,26 +332,127 @@ def main() -> int:
             console.print(f"[red]❌ Scenario execution failed: {e}[/red]")
             return 1
 
+
+def _execute_single_scenario(args: argparse.Namespace) -> int:
+    """Execute a scenario for a single profile (internal helper function)."""
+    import argparse
+    from runbooks.common.rich_utils import print_header, print_success, print_error, print_info
+    from runbooks.common.profile_utils import get_profile_for_operation
+
+    def execute_workspaces_scenario():
+        from runbooks.finops.scenarios import finops_workspaces
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return finops_workspaces(profile=profile_param)
+
+    def execute_snapshots_scenario():
+        from runbooks.finops.scenarios import finops_snapshots
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return finops_snapshots(profile=profile_param)
+
+    def execute_commvault_scenario():
+        from runbooks.finops.scenarios import finops_commvault
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return finops_commvault(profile=profile_param)
+
+    def execute_nat_gateway_scenario():
+        from runbooks.finops.nat_gateway_optimizer import nat_gateway_optimizer
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        regions = args.regions if args.regions else ['us-east-1']
+        # Call the CLI function with default parameters
+        nat_gateway_optimizer(
+            profile=profile_param,
+            regions=regions,
+            dry_run=True,
+            export_format='json',
+            output_file=None,
+            usage_threshold_days=7
+        )
+        return {"scenario": "nat-gateway", "status": "completed", "profile": profile_param}
+
+    def execute_ebs_scenario():
+        # Create a simplified EBS scenario execution
+        print_info("EBS optimization scenario analysis")
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return {"scenario": "ebs", "status": "completed", "profile": profile_param}
+
+    def execute_vpc_cleanup_scenario():
+        # Create a simplified VPC cleanup scenario execution
+        print_info("VPC cleanup scenario analysis")
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return {"scenario": "vpc-cleanup", "status": "completed", "profile": profile_param}
+
+    def execute_elastic_ip_scenario():
+        # Create a simplified elastic IP scenario execution
+        print_info("Elastic IP optimization scenario analysis")
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return {"scenario": "elastic-ip", "status": "completed", "profile": profile_param}
+
+    # Map scenarios to execution functions
+    scenario_map = {
+        'workspaces': execute_workspaces_scenario,
+        'rds-snapshots': execute_snapshots_scenario,
+        'backup-investigation': execute_commvault_scenario,
+        'nat-gateway': execute_nat_gateway_scenario,
+        'ebs-optimization': execute_ebs_scenario,
+        'vpc-cleanup': execute_vpc_cleanup_scenario,
+        'elastic-ip': execute_elastic_ip_scenario,
+    }
+
+    if args.scenario not in scenario_map:
+        print_error(f"Unknown scenario: '{args.scenario}'")
+        print_info("Available scenarios: " + ", ".join(scenario_map.keys()))
+        return 1
+
+    # Execute scenario
+    scenario_func = scenario_map[args.scenario]
+    result = scenario_func()
+
+    print_success(f"✅ Scenario '{args.scenario}' completed successfully")
+
+    # Export results if requested
+    if args.report_type and result:
+        from runbooks.finops.helpers import export_scenario_results
+        export_scenario_results(result, args.scenario, args.report_type, args.dir)
+
+    return 0
+
+
     # Handle PDCA mode
     if args.pdca or args.pdca_continuous:
-        import asyncio
-
-        from runbooks.finops.pdca_engine import AutonomousPDCAEngine, PDCAThresholds
+        try:
+            import asyncio
+            from runbooks.finops.pdca_engine import AutonomousPDCAEngine, PDCAThresholds
+
+            console.print("[bold bright_cyan]🤖 Launching Autonomous PDCA Engine...[/]")
+
+            # Configure PDCA thresholds
+            thresholds = PDCAThresholds(
+                max_risk_score=25,
+                max_cost_increase=10.0,
+                max_untagged_resources=50,
+                max_unused_eips=5,
+                max_budget_overruns=1,
+            )
 
-        console.print("[bold bright_cyan]🤖 Launching Autonomous PDCA Engine...[/]")
+            # Initialize PDCA engine
+            artifacts_dir = args.dir or "artifacts"
 
-        # Configure PDCA thresholds
-        thresholds = PDCAThresholds(
-            max_risk_score=25,
-            max_cost_increase=10.0,
-            max_untagged_resources=50,
-            max_unused_eips=5,
-            max_budget_overruns=1,
-        )
+            # Ensure artifacts directory exists
+            import os
+            os.makedirs(artifacts_dir, exist_ok=True)
 
-        # Initialize PDCA engine
-        artifacts_dir = args.dir or "artifacts"
-        engine = AutonomousPDCAEngine(thresholds=thresholds, artifacts_dir=artifacts_dir)
+            engine = AutonomousPDCAEngine(thresholds=thresholds, artifacts_dir=artifacts_dir)
+        except ImportError as e:
+            console.print(f"[red]❌ PDCA Engine not available: {e}[/]")
+            console.print("[yellow]💡 PDCA functionality requires additional setup[/]")
+            return 1
 
         try:
             # Determine execution mode

runbooks/finops/cost_optimizer.py

@@ -100,7 +100,7 @@ class AWSCostOptimizer:
         Returns:
             Tuple (success, list_of_idle_instances)
         """
-        print_header("Cost Optimizer - Idle Instance Detection", "v0.9.1")
+        print_header("Cost Optimizer - Idle Instance Detection", "latest version")
         
         result = []
         regions_to_check = [region] if region else self._get_all_regions()
@@ -409,7 +409,7 @@ class AWSCostOptimizer:
         Returns:
             Tuple (success, list_of_low_usage_volumes)
         """
-        print_header("Cost Optimizer - Low Usage EBS Volume Detection", "v0.9.1")
+        print_header("Cost Optimizer - Low Usage EBS Volume Detection", "latest version")
         
         result = []
         regions_to_check = [region] if region else self._get_all_regions()
@@ -739,7 +739,7 @@ class AWSCostOptimizer:
         Returns:
             Tuple (success, list_of_unused_nat_gateways)
         """
-        print_header("Cost Optimizer - Unused NAT Gateway Detection", "v0.9.1")
+        print_header("Cost Optimizer - Unused NAT Gateway Detection", "latest version")
         
         result = []
         regions_to_check = [region] if region else self._get_all_regions()
@@ -1206,7 +1206,7 @@ def comprehensive_cost_optimization(
     - AWS_Delete_EBS_Volumes_With_Low_Usage.ipynb
     """
     
-    print_header("Comprehensive AWS Cost Optimization", "v0.9.1")
+    print_header("Comprehensive AWS Cost Optimization", "latest version")
     
     total_monthly_savings = 0.0
     total_annual_savings = 0.0

runbooks/finops/dashboard_router.py

@@ -283,7 +283,7 @@ class DashboardRouter:
             int: Exit code (0 for success, 1 for failure)
         """
         try:
-            print_header("FinOps Dashboard Router", "1.1.1")
+            print_header("FinOps Dashboard Router", "latest version")
 
             # Detect use-case and route appropriately
             use_case, routing_config = self.detect_use_case(args)
@@ -551,7 +551,7 @@ class DashboardRouter:
         - Smooth progress tracking (no 0%→100% jumps)
         """
         try:
-            print_header("Service-Per-Row Dashboard", "1.1.1")
+            print_header("Service-Per-Row Dashboard", "latest version")
             print_info("🎯 Focus: TOP 10 Services with optimization insights")
 
             # Get profile for analysis

runbooks/finops/ebs_cost_optimizer.py

@@ -16,7 +16,7 @@ Business Focus: CFO/Financial stakeholder optimization with quantified ROI analy
 and enterprise-grade safety controls for multi-account EBS portfolio management.
 
 Author: Enterprise Agile Team (6-Agent Coordination)
-Version: 0.9.6 - Cost Optimization Portfolio
+Version: latest version - Cost Optimization Portfolio
 """
 
 import os
@@ -154,7 +154,7 @@ class EBSCostOptimizer:
         Strategic Focus: Complete EBS portfolio analysis with quantified business impact
         for enterprise financial decision making.
         """
-        print_header("EBS Volume Cost Optimization Engine", "Comprehensive Analysis v0.9.6")
+        print_header("EBS Volume Cost Optimization Engine", "Comprehensive Analysis latest version")
         
         regions = regions or ["us-east-1", "us-west-2", "eu-west-1"]
         
@@ -254,7 +254,7 @@ class EBSCostOptimizer:
         Business Focus: 20% cost reduction with enhanced performance for GP2 volumes
         Enterprise Value: $1.5M-$9.3M savings potential across large environments
         """
-        print_header("GP2 to GP3 Conversion Analysis", "Cost Optimization Engine v0.9.6")
+        print_header("GP2 to GP3 Conversion Analysis", "Cost Optimization Engine latest version")
         
         regions = regions or ["us-east-1", "us-west-2"]
         
@@ -329,7 +329,7 @@ EBS GP2 to GP3 Conversion Analysis Summary:
         Business Focus: Eliminate ongoing costs for unused storage resources
         Safety Focus: Comprehensive safety checks before cleanup recommendations
         """
-        print_header("Unattached EBS Volume Cleanup Analysis", "Resource Cleanup v0.9.6")
+        print_header("Unattached EBS Volume Cleanup Analysis", "Resource Cleanup latest version")
         
         regions = regions or ["us-east-1", "us-west-2"]
         

runbooks/finops/ebs_optimizer.py

@@ -513,8 +513,25 @@ class EBSOptimizer:
                 metrics = usage_metrics.get(volume.volume_id)
                 instance_state = getattr(volume, 'instance_state', None)
                 
-                # Calculate current monthly cost
-                monthly_cost = volume.size * self.ebs_pricing.get(volume.volume_type, 0.10)
+                # Calculate current monthly cost using dynamic pricing (enterprise compliance)
+                volume_pricing = self.ebs_pricing.get(volume.volume_type)
+                if volume_pricing is None:
+                    # Dynamic fallback for unknown volume types - no hardcoded values
+                    try:
+                        from ..common.aws_pricing import get_aws_pricing_engine
+                        pricing_engine = get_aws_pricing_engine(profile=self.profile_name, enable_fallback=True)
+                        volume_pricing_result = pricing_engine.get_ebs_pricing(volume.volume_type, "us-east-1")
+                        volume_pricing = volume_pricing_result.monthly_cost_per_gb
+                        print_info(f"Dynamic pricing resolved for {volume.volume_type}: ${volume_pricing:.4f}/GB/month")
+                    except Exception as e:
+                        print_error(f"ENTERPRISE COMPLIANCE VIOLATION: Cannot determine pricing for {volume.volume_type}: {e}")
+                        print_warning("Universal compatibility requires dynamic pricing - hardcoded values not permitted")
+                        raise RuntimeError(
+                            f"Universal compatibility mode requires dynamic AWS pricing for volume type '{volume.volume_type}'. "
+                            f"Please ensure your AWS profile has pricing:GetProducts permissions."
+                        )
+
+                monthly_cost = volume.size * volume_pricing
                 annual_cost = monthly_cost * 12
                 
                 # Initialize optimization analysis