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

runbooks/inventory/organizations_discovery.py

@@ -39,32 +39,34 @@ from ..common.performance_optimization_engine import get_optimization_engine
 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
-}
+_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']:
+    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']:
+
+    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 _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]")
+    _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]"
+    )
+
 
 # Universal AWS Environment Profile Support (Compatible with ANY AWS Setup)
 import os
+
 ENTERPRISE_PROFILES = {
     "BILLING_PROFILE": os.getenv("BILLING_PROFILE", "default"),  # Universal compatibility
     "MANAGEMENT_PROFILE": os.getenv("MANAGEMENT_PROFILE", "default"),  # Works with any profile
@@ -246,40 +248,44 @@ class EnhancedOrganizationsDiscovery:
         """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 
+
+        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'):
+        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]")
-        
+            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]:
@@ -417,13 +423,13 @@ class EnhancedOrganizationsDiscovery:
         """
         # Get performance optimization engine
         optimization_engine = get_optimization_engine(
-            max_workers=self.max_workers,
-            cache_ttl_minutes=30,
-            memory_limit_mb=2048
+            max_workers=self.max_workers, cache_ttl_minutes=30, memory_limit_mb=2048
         )
-        
+
         # Use optimized discovery with performance monitoring
-        with optimization_engine.optimize_operation("organization_structure_discovery", self.performance_target_seconds):
+        with optimization_engine.optimize_operation(
+            "organization_structure_discovery", self.performance_target_seconds
+        ):
             return await self._discover_organization_structure_optimized(optimization_engine)
 
     async def _discover_organization_structure_optimized(self, optimization_engine) -> Dict:
@@ -436,7 +442,7 @@ class EnhancedOrganizationsDiscovery:
         )
 
         logger.info("🏢 Starting optimized organization structure discovery with SRE automation patterns")
-        
+
         # Check global cache first to prevent duplicate calls
         cached_result = _get_global_organizations_cache()
         if cached_result:
@@ -446,7 +452,7 @@ class EnhancedOrganizationsDiscovery:
             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"):
@@ -561,10 +567,10 @@ 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:
@@ -606,7 +612,7 @@ class EnhancedOrganizationsDiscovery:
     async def _discover_accounts_optimized(self, optimization_engine) -> Dict:
         """
         Optimized account discovery using performance optimization engine
-        
+
         Addresses: Organization Discovery Performance (52.3s -> <30s target)
         Features:
         - Intelligent caching with TTL management
@@ -615,46 +621,44 @@ class EnhancedOrganizationsDiscovery:
         - Memory-efficient processing
         """
         logger.info("📊 Discovering organization accounts with SRE optimization patterns")
-        
+
         # Use optimization engine for discovery
         optimized_discover_accounts = optimization_engine.optimize_organization_discovery(
-            management_profile=self.management_profile,
-            use_parallel_processing=True,
-            batch_size=20
+            management_profile=self.management_profile, use_parallel_processing=True, batch_size=20
         )
-        
+
         # Execute optimized discovery
         try:
             result = optimized_discover_accounts()
-            
+
             # Convert to expected format
-            accounts_data = result.get('accounts', [])
-            
+            accounts_data = result.get("accounts", [])
+
             # Create AWSAccount objects for compatibility
             for account_data in accounts_data:
                 account = AWSAccount(
                     account_id=account_data["Id"],
-                    name=account_data["Name"], 
+                    name=account_data["Name"],
                     email=account_data["Email"],
                     status=account_data["Status"],
                     joined_method=account_data["JoinedMethod"],
                     joined_timestamp=account_data.get("JoinedTimestamp"),
-                    tags=account_data.get("Tags", {})
+                    tags=account_data.get("Tags", {}),
                 )
                 self.accounts_cache[account.account_id] = account
-            
+
             # Update metrics
             self.discovery_metrics["accounts_discovered"] = len(accounts_data)
-            
+
             # Enhanced account categorization
             active_accounts = [a for a in accounts_data if a.get("Status") == "ACTIVE"]
-            suspended_accounts = [a for a in accounts_data if a.get("Status") == "SUSPENDED"] 
+            suspended_accounts = [a for a in accounts_data if a.get("Status") == "SUSPENDED"]
             closed_accounts = [a for a in accounts_data if a.get("Status") == "CLOSED"]
-            
-            optimization_info = result.get('optimizations_applied', [])
+
+            optimization_info = result.get("optimizations_applied", [])
             logger.info(f"✅ Optimized discovery: {len(accounts_data)} accounts ({len(active_accounts)} active)")
             logger.info(f"🚀 Optimizations applied: {', '.join(optimization_info)}")
-            
+
             return {
                 "total_accounts": len(accounts_data),
                 "active_accounts": len(active_accounts),
@@ -665,7 +669,7 @@ class EnhancedOrganizationsDiscovery:
                 "profile_used": "management",
                 "optimizations_applied": optimization_info,
             }
-            
+
         except Exception as e:
             logger.error(f"Optimized account discovery failed: {e}")
             # Fallback to original method

runbooks/inventory/rich_inventory_display.py

@@ -349,18 +349,18 @@ def display_account_tree(accounts_data: Dict[str, Dict]) -> None:
 
 
 def display_results_rich(
-    results_list: List[Dict[str, Any]], 
-    fdisplay_dict: Dict[str, Dict], 
-    defaultAction: Any = None, 
-    file_to_save: Optional[str] = None, 
+    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"
+    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:
@@ -369,7 +369,7 @@ def display_results_rich(
         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'},
@@ -379,59 +379,60 @@ def display_results_rich(
         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))
-    
+    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')}"
+        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)
+        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', [])
+            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:
+
+            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:
@@ -441,7 +442,7 @@ def display_results_rich(
 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
@@ -454,21 +455,21 @@ def display_progress_rich(current: int, total: int, description: str = "Processi
 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", 
+        "green": "green",
         "yellow": "yellow",
         "cyan": "cyan",
         "blue": "blue",
         "white": "white",
-        "magenta": "magenta"
+        "magenta": "magenta",
     }
-    
+
     rich_color = color_map.get(color.lower(), "white")
     console.print(f"[{rich_color}]{text}[/{rich_color}]")
 
@@ -476,13 +477,13 @@ def print_colorized_rich(text: str, color: str = "white") -> None:
 # 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", 
+    "display_progress_rich",
     "print_colorized_rich",
 ]