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

runbooks/inventory/mcp_vpc_validator.py

@@ -779,15 +779,32 @@ class AWSO5MCPValidator:
             print_warning(f"Flow Logs validation failed: {e}")
     
     def _calculate_accuracy(self, runbooks_value: Any, mcp_value: Any) -> float:
-        """Calculate accuracy percentage between runbooks and MCP values."""
+        """Calculate accuracy percentage between runbooks and MCP values with enterprise tolerance."""
         
         if isinstance(runbooks_value, (int, float)) and isinstance(mcp_value, (int, float)):
-            if mcp_value == 0:
-                return 100.0 if runbooks_value == 0 else 0.0
+            # Perfect match
+            if runbooks_value == mcp_value:
+                return 100.0
             
-            variance = abs(runbooks_value - mcp_value) / max(abs(mcp_value), 1)
-            accuracy = max(0, 100 - (variance * 100))
-            return min(100.0, accuracy)
+            # Both zero
+            if mcp_value == 0 and runbooks_value == 0:
+                return 100.0
+            
+            # One zero, other non-zero
+            if mcp_value == 0 or runbooks_value == 0:
+                return 0.0
+            
+            # Calculate percentage variance
+            max_value = max(abs(runbooks_value), abs(mcp_value))
+            variance_percent = abs(runbooks_value - mcp_value) / max_value * 100
+            
+            # Apply enterprise tolerance (±5% acceptable)
+            if variance_percent <= 5.0:
+                return 100.0
+            else:
+                # Scale accuracy based on variance beyond tolerance
+                accuracy = max(0.0, 100.0 - (variance_percent - 5.0))
+                return min(100.0, accuracy)
         
         elif runbooks_value == mcp_value:
             return 100.0

runbooks/inventory/organizations_discovery.py

@@ -37,6 +37,31 @@ from ..utils.logger import configure_logger
 
 logger = configure_logger(__name__)
 
+# Global Organizations cache to prevent duplicate API calls across all instances
+_GLOBAL_ORGS_CACHE = {
+    'data': None,
+    'timestamp': None,
+    'ttl_minutes': 30
+}
+
+def _get_global_organizations_cache():
+    """Get cached Organizations data if valid (module-level cache)."""
+    if not _GLOBAL_ORGS_CACHE['timestamp']:
+        return None
+    
+    cache_age_minutes = (datetime.now(timezone.utc) - _GLOBAL_ORGS_CACHE['timestamp']).total_seconds() / 60
+    if cache_age_minutes < _GLOBAL_ORGS_CACHE['ttl_minutes']:
+        console.print("[blue]🚀 Global performance optimization: Using cached Organizations data[/blue]")
+        return _GLOBAL_ORGS_CACHE['data']
+    return None
+
+def _set_global_organizations_cache(data):
+    """Cache Organizations data globally (module-level cache)."""
+    _GLOBAL_ORGS_CACHE['data'] = data
+    _GLOBAL_ORGS_CACHE['timestamp'] = datetime.now(timezone.utc)
+    accounts_count = len(data.get('accounts', {}).get('discovered_accounts', [])) if data else 0
+    console.print(f"[green]✅ Global Organizations cache: {accounts_count} accounts (TTL: {_GLOBAL_ORGS_CACHE['ttl_minutes']}min)[/green]")
+
 # Enterprise 4-Profile AWS SSO Architecture (Proven FinOps Success Pattern)
 ENTERPRISE_PROFILES = {
     "BILLING_PROFILE": "ams-admin-Billing-ReadOnlyAccess-909135376185",  # Cost Explorer access
@@ -210,6 +235,51 @@ class EnhancedOrganizationsDiscovery:
             "performance_grade": None,
         }
 
+        # Organizations discovery cache to prevent duplicate calls (performance optimization)
+        self._organizations_cache = None
+        self._organizations_cache_timestamp = None
+        self._cache_ttl_minutes = 30
+
+    def _is_organizations_cache_valid(self) -> bool:
+        """Check if Organizations cache is still valid."""
+        if not self._organizations_cache_timestamp:
+            return False
+        
+        from datetime import datetime, timedelta
+        cache_age_minutes = (datetime.now() - self._organizations_cache_timestamp).total_seconds() / 60
+        return cache_age_minutes < self._cache_ttl_minutes
+
+    async def discover_all_accounts(self) -> Dict:
+        """
+        Cached wrapper for Organizations discovery to prevent duplicate API calls.
+        
+        This method implements both global and instance-level caching to avoid the 
+        performance penalty of duplicate Organizations API calls when multiple 
+        components need the same account data.
+        """
+        # Check global cache first (shared across all instances)
+        global_cached_result = _get_global_organizations_cache()
+        if global_cached_result:
+            return global_cached_result
+        
+        # Check instance cache
+        if self._is_organizations_cache_valid() and self._organizations_cache:
+            console.print("[blue]🚀 Performance optimization: Using cached Organizations data[/blue]")
+            return self._organizations_cache
+        
+        # Cache miss - perform discovery
+        console.print("[cyan]🔍 Performing Organizations discovery (cache miss)[/cyan]")
+        results = await self.discover_organization_structure()
+        
+        # Cache the results
+        if results and results.get('accounts'):
+            self._organizations_cache = results
+            from datetime import datetime
+            self._organizations_cache_timestamp = datetime.now()
+            console.print(f"[green]✅ Cached Organizations data: {len(results.get('accounts', {}).get('discovered_accounts', []))} accounts (TTL: {self._cache_ttl_minutes}min)[/green]")
+        
+        return results
+
     def initialize_sessions(self) -> Dict[str, str]:
         """
         Initialize AWS sessions with 4-profile architecture and comprehensive validation
@@ -350,6 +420,17 @@ class EnhancedOrganizationsDiscovery:
         )
 
         logger.info("🏢 Starting enhanced organization structure discovery with performance tracking")
+        
+        # Check global cache first to prevent duplicate calls
+        cached_result = _get_global_organizations_cache()
+        if cached_result:
+            # Update metrics and return cached result
+            self.current_benchmark.finish(success=True)
+            self.discovery_metrics["performance_grade"] = self.current_benchmark.get_performance_grade()
+            self.discovery_metrics["end_time"] = self.current_benchmark.end_time
+            self.discovery_metrics["duration_seconds"] = self.current_benchmark.duration_seconds
+            return cached_result
+            
         self.discovery_metrics["start_time"] = self.current_benchmark.start_time
 
         with Status("Initializing enterprise discovery...", console=console, spinner="dots"):
@@ -452,7 +533,7 @@ class EnhancedOrganizationsDiscovery:
                 performance_benchmark_dict = asdict(self.current_benchmark)
                 performance_benchmark_dict["performance_grade"] = self.current_benchmark.get_performance_grade()
 
-                return {
+                discovery_result = {
                     "status": "completed",
                     "discovery_type": "enhanced_organization_structure",
                     "organization_info": org_info,
@@ -464,6 +545,11 @@ class EnhancedOrganizationsDiscovery:
                     "performance_benchmark": performance_benchmark_dict,
                     "timestamp": datetime.now().isoformat(),
                 }
+                
+                # Cache the successful result to prevent duplicate calls
+                _set_global_organizations_cache(discovery_result)
+                
+                return discovery_result
 
             except Exception as e:
                 # Handle discovery failure
@@ -1313,3 +1399,7 @@ if __name__ == "__main__":
         )
 
     asyncio.run(main())
+
+
+# Alias for backward compatibility
+OrganizationsDiscoveryEngine = EnhancedOrganizationsDiscovery

runbooks/inventory/rich_inventory_display.py

@@ -348,13 +348,141 @@ def display_account_tree(accounts_data: Dict[str, Dict]) -> None:
     console.print(tree)
 
 
+def display_results_rich(
+    results_list: List[Dict[str, Any]], 
+    fdisplay_dict: Dict[str, Dict], 
+    defaultAction: Any = None, 
+    file_to_save: Optional[str] = None, 
+    subdisplay: bool = False,
+    title: str = "Inventory Results"
+) -> None:
+    """
+    Rich CLI replacement for legacy display_results function.
+    
+    Provides backwards-compatible interface while using Rich formatting.
+    
+    Args:
+        results_list: List of dictionaries with resource data
+        fdisplay_dict: Display configuration dictionary with format:
+            {'FieldName': {'DisplayOrder': 1, 'Heading': 'Display Name', 'Condition': [optional_filter]}}
+        defaultAction: Default value for missing fields
+        file_to_save: Optional filename to save results
+        subdisplay: Whether this is a sub-display (affects formatting)
+        title: Title for the table display
+    
+    Example:
+        display_dict = {
+            'AccountId': {'DisplayOrder': 1, 'Heading': 'Account'},
+            'Region': {'DisplayOrder': 2, 'Heading': 'Region'},
+            'InstanceId': {'DisplayOrder': 3, 'Heading': 'Instance ID'}
+        }
+        display_results_rich(instance_data, display_dict, title="EC2 Instances")
+    """
+    from datetime import datetime
+    
+    if not results_list:
+        print_info("ℹ️ No results to display")
+        return
+        
+    # Sort display fields by DisplayOrder
+    sorted_fields = sorted(fdisplay_dict.items(), key=lambda x: x[1].get('DisplayOrder', 999))
+    
+    # Create Rich table
+    table = create_table(
+        title=f"📊 {title}",
+        caption=f"Found {len(results_list)} results • {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+    )
+    
+    # Add columns based on display dictionary
+    for field_name, field_config in sorted_fields:
+        heading = field_config.get('Heading', field_name)
+        table.add_column(heading, style="cyan" if "Id" in field_name else "white", no_wrap=True)
+    
+    # Add rows
+    for result in results_list[:100]:  # Limit to first 100 for performance
+        row_data = []
+        
+        for field_name, field_config in sorted_fields:
+            # Apply condition filter if specified
+            condition = field_config.get('Condition', [])
+            if condition:
+                value = result.get(field_name, defaultAction)
+                if value not in condition:
+                    continue
+                    
+            # Get field value with default fallback
+            value = result.get(field_name, defaultAction)
+            if value is None:
+                value = "N/A"
+            
+            # Format value as string
+            row_data.append(str(value)[:50])  # Truncate long values
+        
+        table.add_row(*row_data)
+    
+    # Display the table
+    console.print(table)
+    
+    # Show truncation notice if needed
+    if len(results_list) > 100:
+        console.print(f"[dim]Showing first 100 results. Total found: {len(results_list)}[/dim]")
+    
+    # Save to file if requested
+    if file_to_save:
+        try:
+            import json
+            with open(file_to_save, 'w') as f:
+                json.dump(results_list, f, indent=2, default=str)
+            print_success(f"💾 Results saved to: {file_to_save}")
+        except Exception as e:
+            print_error(f"Failed to save file: {e}")
+
+
+def display_progress_rich(current: int, total: int, description: str = "Processing") -> None:
+    """
+    Rich CLI replacement for legacy progress indicators.
+    
+    Args:
+        current: Current progress count
+        total: Total items to process
+        description: Description of the operation
+    """
+    percentage = (current / total * 100) if total > 0 else 0
+    console.print(f"[cyan]{description}:[/cyan] {current}/{total} ({percentage:.1f}%)", end="\r")
+
+
+def print_colorized_rich(text: str, color: str = "white") -> None:
+    """
+    Rich CLI replacement for colorama print statements.
+    
+    Args:
+        text: Text to print
+        color: Color name (red, green, yellow, cyan, blue, white)
+    """
+    color_map = {
+        "red": "red",
+        "green": "green", 
+        "yellow": "yellow",
+        "cyan": "cyan",
+        "blue": "blue",
+        "white": "white",
+        "magenta": "magenta"
+    }
+    
+    rich_color = color_map.get(color.lower(), "white")
+    console.print(f"[{rich_color}]{text}[/{rich_color}]")
+
+
 # Export public functions
 __all__ = [
     "display_inventory_header",
-    "create_inventory_progress",
+    "create_inventory_progress", 
     "display_ec2_inventory_results",
     "display_generic_inventory_results",
     "display_inventory_error",
     "display_multi_resource_summary",
     "display_account_tree",
+    "display_results_rich",
+    "display_progress_rich", 
+    "print_colorized_rich",
 ]