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

runbooks/utils/__init__.py

@@ -86,7 +86,9 @@ def setup_logging(debug: bool = False, log_file: Optional[str] = None) -> None:
             log_path.parent.mkdir(parents=True, exist_ok=True)
             file_handler = logging.FileHandler(log_path)
             file_handler.setLevel(log_level_value)
-            formatter = logging.Formatter("%(asctime)s | %(levelname)-8s | %(name)s:%(funcName)s:%(lineno)d - %(message)s")
+            formatter = logging.Formatter(
+                "%(asctime)s | %(levelname)-8s | %(name)s:%(funcName)s:%(lineno)d - %(message)s"
+            )
             file_handler.setFormatter(formatter)
             logging.getLogger().addHandler(file_handler)
 
@@ -94,7 +96,7 @@ def setup_logging(debug: bool = False, log_file: Optional[str] = None) -> None:
 def setup_enhanced_logging(log_level: str = "INFO", json_output: bool = False, debug: bool = False) -> None:
     """
     Configure enhanced enterprise logging with Rich CLI integration and user-type specific output.
-    
+
     This function initializes the global enhanced logger that provides:
     - User-type specific formatting (DEBUG=tech, INFO=standard, WARNING=business, ERROR=all)
     - Rich CLI integration with beautiful formatting
@@ -102,7 +104,7 @@ def setup_enhanced_logging(log_level: str = "INFO", json_output: bool = False, d
     - AWS API tracing for technical users
     - Business recommendations for warning level
     - Clear error solutions for all users
-    
+
     Args:
         log_level: Log level (DEBUG, INFO, WARNING, ERROR)
         json_output: Enable structured JSON output for programmatic use
@@ -111,41 +113,36 @@ def setup_enhanced_logging(log_level: str = "INFO", json_output: bool = False, d
     try:
         from runbooks.enterprise.logging import configure_enterprise_logging, get_context_logger
         from runbooks.common.rich_utils import get_context_aware_console
-        
+
         # Override level if debug flag is set (backward compatibility)
         if debug:
             log_level = "DEBUG"
-            
+
         # Get context-aware console for Rich CLI integration
         try:
             rich_console = get_context_aware_console()
         except ImportError:
             rich_console = None
-            
+
         # Configure global enhanced logger
-        logger = configure_enterprise_logging(
-            level=log_level,
-            rich_console=rich_console,
-            json_output=json_output
-        )
-        
+        logger = configure_enterprise_logging(level=log_level, rich_console=rich_console, json_output=json_output)
+
         # Log initialization success with user-type appropriate message
         if log_level == "DEBUG":
             logger.debug_tech(
                 "Enhanced logging initialized with Rich CLI integration",
                 aws_api={"service": "logging", "operation": "initialize"},
-                duration=0.001
+                duration=0.001,
             )
         elif log_level == "INFO":
             logger.info_standard("CloudOps Runbooks logging initialized")
         elif log_level == "WARNING":
             logger.warning_business(
-                "Business-focused logging enabled", 
-                recommendation="Use --log-level INFO for standard operations"
+                "Business-focused logging enabled", recommendation="Use --log-level INFO for standard operations"
             )
         else:
             logger.error_all("Minimal error-only logging enabled")
-            
+
     except ImportError as e:
         # Fallback to standard logging if enhanced logging not available
         setup_logging(debug=debug)
@@ -272,7 +269,7 @@ __all__ = [
     "configure_logger",
     # Version management
     "check_pyproject_version",
-    "get_all_module_versions", 
+    "get_all_module_versions",
     "print_version_report",
     "validate_version_consistency",
     "VersionDriftError",

runbooks/utils/logger.py

@@ -1,4 +1,6 @@
 import logging
+import os
+import tempfile
 
 
 ## ==============================
@@ -24,8 +26,11 @@ def configure_logger(module_name: str) -> logging.Logger:
     console_handler = logging.StreamHandler()
     console_handler.setFormatter(formatter)
 
-    ## File Handler
-    file_handler = logging.FileHandler(f"{module_name}.log")
+    ## File Handler - Fix: Use user directory instead of root
+    log_dir = os.path.expanduser("~/.runbooks/logs")
+    os.makedirs(log_dir, exist_ok=True)
+    log_file = os.path.join(log_dir, f"{module_name.replace('.', '_')}.log")
+    file_handler = logging.FileHandler(log_file)
     file_handler.setFormatter(formatter)
 
     ## Add handlers if not already added

runbooks/utils/version_validator.py

@@ -12,64 +12,66 @@ from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
 # Avoid circular imports by defining central version directly
-CENTRAL_VERSION = "1.1.1"  # Must match runbooks.__init__.__version__
+CENTRAL_VERSION = "latest version"  # Must match runbooks.__init__.__version__
 
 
 class VersionDriftError(Exception):
     """Raised when version drift is detected in CI/CD pipeline."""
+
     pass
 
 
 def get_all_module_versions() -> Dict[str, str]:
     """
     Collect versions from all runbooks modules.
-    
+
     Returns:
         Dict mapping module names to their reported versions
     """
     modules = [
         "runbooks",
         "runbooks.finops",
-        "runbooks.operate", 
+        "runbooks.operate",
         "runbooks.security",
         "runbooks.cfat",
         "runbooks.inventory",
         "runbooks.remediation",
         "runbooks.vpc",
         "runbooks.sre",
-        "runbooks.cloudops"
+        "runbooks.cloudops",
     ]
-    
+
     versions = {}
-    
+
     for module_name in modules:
         try:
             # Import the module
             module = importlib.import_module(module_name)
-            
+
             # Get version
-            if hasattr(module, '__version__'):
+            if hasattr(module, "__version__"):
                 versions[module_name] = module.__version__
             else:
                 versions[module_name] = "No version found"
-                
+
         except ImportError as e:
             versions[module_name] = f"Import error: {e}"
         except Exception as e:
             versions[module_name] = f"Error: {e}"
-            
+
     return versions
 
 
 def check_pyproject_version() -> Tuple[bool, str, str]:
     """
     Check if pyproject.toml version matches centralized version.
-    
+
     Returns:
         Tuple of (is_matching, pyproject_version, central_version)
     """
     try:
         from importlib.metadata import version as _pkg_version
+
         pyproject_version = _pkg_version("runbooks")
         return (pyproject_version == CENTRAL_VERSION, pyproject_version, CENTRAL_VERSION)
     except Exception as e:
@@ -79,13 +81,13 @@ def check_pyproject_version() -> Tuple[bool, str, str]:
 def validate_version_consistency(strict: bool = False) -> Dict[str, any]:
     """
     Validate version consistency across all modules.
-    
+
     Args:
         strict: If True, raise VersionDriftError on inconsistencies
-        
+
     Returns:
         Dictionary with validation results
-        
+
     Raises:
         VersionDriftError: If strict=True and inconsistencies found
     """
@@ -94,25 +96,25 @@ def validate_version_consistency(strict: bool = False) -> Dict[str, any]:
         "module_versions": get_all_module_versions(),
         "pyproject_check": check_pyproject_version(),
         "inconsistencies": [],
-        "all_consistent": True
+        "all_consistent": True,
     }
-    
+
     # Check module versions
     for module_name, module_version in results["module_versions"].items():
         if module_name == "runbooks":
             continue  # Skip root module
-            
+
         if isinstance(module_version, str) and not module_version.startswith(("Error:", "No version", "Import error:")):
             if module_version != CENTRAL_VERSION:
                 inconsistency = {
                     "module": module_name,
                     "expected": CENTRAL_VERSION,
                     "found": module_version,
-                    "type": "module_version_mismatch"
+                    "type": "module_version_mismatch",
                 }
                 results["inconsistencies"].append(inconsistency)
                 results["all_consistent"] = False
-    
+
     # Check pyproject.toml
     is_matching, pyproject_version, _ = results["pyproject_check"]
     if not is_matching and not pyproject_version.startswith("Error:"):
@@ -120,18 +122,18 @@ def validate_version_consistency(strict: bool = False) -> Dict[str, any]:
             "module": "pyproject.toml",
             "expected": CENTRAL_VERSION,
             "found": pyproject_version,
-            "type": "pyproject_version_mismatch"
+            "type": "pyproject_version_mismatch",
         }
         results["inconsistencies"].append(inconsistency)
         results["all_consistent"] = False
-    
+
     # Raise error in strict mode
     if strict and not results["all_consistent"]:
         error_msg = f"Version drift detected:\n"
         for inc in results["inconsistencies"]:
             error_msg += f"  - {inc['module']}: expected {inc['expected']}, got {inc['found']}\n"
         raise VersionDriftError(error_msg)
-    
+
     return results
 
 
@@ -141,23 +143,25 @@ def print_version_report() -> None:
         from rich.console import Console
         from rich.table import Table
         from rich.panel import Panel
-        
+
         console = Console()
         validation_results = validate_version_consistency()
-        
+
         # Header
-        console.print(Panel(
-            f"[bold blue]Version Management Report[/bold blue]\n"
-            f"Central Version: [green]{validation_results['central_version']}[/green]",
-            title="Runbooks Version Validation"
-        ))
-        
+        console.print(
+            Panel(
+                f"[bold blue]Version Management Report[/bold blue]\n"
+                f"Central Version: [green]{validation_results['central_version']}[/green]",
+                title="Runbooks Version Validation",
+            )
+        )
+
         # Module versions table
         table = Table(title="Module Version Status")
         table.add_column("Module", style="cyan")
         table.add_column("Version", style="green")
         table.add_column("Status", style="magenta")
-        
+
         for module_name, version in validation_results["module_versions"].items():
             if isinstance(version, str) and version.startswith(("Error:", "No version", "Import error:")):
                 status = "[red]Error[/red]"
@@ -168,18 +172,18 @@ def print_version_report() -> None:
             else:
                 status = "[red]✗ Mismatch[/red]"
                 version_display = f"[red]{version}[/red]"
-                
+
             table.add_row(module_name, version_display, status)
-        
+
         console.print(table)
-        
+
         # Pyproject.toml check
         is_matching, pyproject_version, central_version = validation_results["pyproject_check"]
         if is_matching:
             console.print("[green]✓ pyproject.toml version matches central version[/green]")
         else:
             console.print(f"[red]✗ pyproject.toml version mismatch: {pyproject_version} vs {central_version}[/red]")
-        
+
         # Overall status
         if validation_results["all_consistent"]:
             console.print("\n[bold green]✓ All versions are consistent[/bold green]")
@@ -187,24 +191,24 @@ def print_version_report() -> None:
             console.print("\n[bold red]✗ Version inconsistencies detected[/bold red]")
             for inc in validation_results["inconsistencies"]:
                 console.print(f"  - {inc['module']}: expected {inc['expected']}, got {inc['found']}")
-                
+
     except ImportError:
         # Fallback without Rich
         validation_results = validate_version_consistency()
-        
+
         print(f"=== Version Management Report ===")
         print(f"Central Version: {validation_results['central_version']}")
         print()
-        
+
         print("Module Versions:")
         for module_name, version in validation_results["module_versions"].items():
             status = "OK" if version == validation_results["central_version"] else "MISMATCH"
             print(f"  {module_name}: {version} ({status})")
-        
+
         is_matching, pyproject_version, _ = validation_results["pyproject_check"]
         pyproject_status = "OK" if is_matching else "MISMATCH"
         print(f"  pyproject.toml: {pyproject_version} ({pyproject_status})")
-        
+
         if validation_results["all_consistent"]:
             print("\n✓ All versions are consistent")
         else:
@@ -216,19 +220,18 @@ def print_version_report() -> None:
 def cli_main():
     """CLI entry point for version validation."""
     import argparse
-    
+
     parser = argparse.ArgumentParser(description="Validate runbooks version consistency")
-    parser.add_argument("--strict", action="store_true", 
-                       help="Exit with error code if inconsistencies found")
-    
+    parser.add_argument("--strict", action="store_true", help="Exit with error code if inconsistencies found")
+
     args = parser.parse_args()
-    
+
     try:
         print_version_report()
-        
+
         if args.strict:
             validate_version_consistency(strict=True)
-            
+
     except VersionDriftError as e:
         print(f"\nERROR: {e}")
         sys.exit(1)
@@ -238,4 +241,4 @@ def cli_main():
 
 
 if __name__ == "__main__":
-    cli_main()
+    cli_main()

runbooks/validation/__init__.py

@@ -15,16 +15,16 @@ ENHANCED CAPABILITIES:
 from .mcp_validator import MCPValidator, ValidationReport, ValidationResult, ValidationStatus
 from .comprehensive_2way_validator import (
     Comprehensive2WayValidator,
-    ValidationDiscrepancy, 
-    Comprehensive2WayValidationResult
+    ValidationDiscrepancy,
+    Comprehensive2WayValidationResult,
 )
 
 __all__ = [
-    "MCPValidator", 
-    "ValidationResult", 
-    "ValidationReport", 
+    "MCPValidator",
+    "ValidationResult",
+    "ValidationReport",
     "ValidationStatus",
     "Comprehensive2WayValidator",
     "ValidationDiscrepancy",
-    "Comprehensive2WayValidationResult"
+    "Comprehensive2WayValidationResult",
 ]

runbooks/validation/cli.py

@@ -88,7 +88,9 @@ def validate_all(tolerance: float, performance_target: float, save_report: bool,
 
 
 @cli.command()
-@click.option("--profile", default=lambda: os.getenv("BILLING_PROFILE", "default-billing-profile"), help="AWS billing profile")
+@click.option(
+    "--profile", default=lambda: os.getenv("BILLING_PROFILE", "default-billing-profile"), help="AWS billing profile"
+)
 @click.option("--tolerance", default=5.0, help="Cost variance tolerance percentage")
 def validate_costs(profile: str, tolerance: float):
     """Validate Cost Explorer data accuracy."""
@@ -140,7 +142,11 @@ def validate_costs(profile: str, tolerance: float):
 
 
 @cli.command()
-@click.option("--profile", default=lambda: os.getenv("MANAGEMENT_PROFILE", "default-management-profile"), help="AWS management profile")
+@click.option(
+    "--profile",
+    default=lambda: os.getenv("MANAGEMENT_PROFILE", "default-management-profile"),
+    help="AWS management profile",
+)
 def validate_organizations(profile: str):
     """Validate Organizations API data accuracy."""
 
@@ -322,7 +328,7 @@ def status():
 
     # Check MCP integration
     try:
-        from notebooks.mcp_integration import MCPIntegrationManager
+        from runbooks.mcp import MCPIntegrationManager
 
         table.add_row("MCP Integration", "[green]✅ Available[/green]", "Ready for validation")
     except ImportError: