runbooks 0.7.6__py3-none-any.whl → 0.7.9__py3-none-any.whl

runbooks/cfat/assessment/runner.py

@@ -22,6 +22,11 @@ from datetime import datetime
 from typing import Dict, List, Optional, Set
 
 from loguru import logger
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn, BarColumn
+from rich.table import Table
+from rich.live import Live
 
 from runbooks import __version__
 from runbooks.base import CloudFoundationsBase, ProgressTracker
@@ -35,6 +40,17 @@ from runbooks.cfat.models import (
 )
 from runbooks.config import RunbooksConfig
 
+# Enterprise 4-Profile Architecture - Proven FinOps Patterns
+ENTERPRISE_PROFILES = {
+    "BILLING_PROFILE": "ams-admin-Billing-ReadOnlyAccess-909135376185",
+    "MANAGEMENT_PROFILE": "ams-admin-ReadOnlyAccess-909135376185", 
+    "CENTRALISED_OPS_PROFILE": "ams-centralised-ops-ReadOnlyAccess-335083429030",
+    "SINGLE_ACCOUNT_PROFILE": "ams-shared-services-non-prod-ReadOnlyAccess-499201730520"
+}
+
+# Rich console instance for consistent formatting
+console = Console()
+
 
 class CloudFoundationsAssessment(CloudFoundationsBase):
     """
@@ -80,8 +96,8 @@ class CloudFoundationsAssessment(CloudFoundationsBase):
         report = assessment.run_assessment()
 
         # Analyze results
-        print(f"Compliance Score: {report.summary.compliance_score}/100")
-        print(f"Critical Issues: {report.summary.critical_issues}")
+        console.print(f"[green]Compliance Score: {report.summary.compliance_score}/100[/green]")
+        console.print(f"[red]Critical Issues: {report.summary.critical_issues}[/red]")
 
         # Export in multiple formats
         report.to_html("compliance_report.html")
@@ -96,10 +112,28 @@ class CloudFoundationsAssessment(CloudFoundationsBase):
     def __init__(
         self, profile: Optional[str] = None, region: Optional[str] = None, config: Optional[RunbooksConfig] = None
     ):
-        """Initialize assessment runner."""
-        super().__init__(profile, region, config)
+        """Initialize assessment runner with enterprise profile support."""
+        # Support enterprise profile shortcuts
+        if profile in ENTERPRISE_PROFILES:
+            actual_profile = ENTERPRISE_PROFILES[profile]
+            console.print(f"[blue]🏢 Using enterprise profile: {profile} -> {actual_profile}[/blue]")
+            super().__init__(actual_profile, region, config)
+        else:
+            super().__init__(profile, region, config)
+            
         self.assessment_config = AssessmentConfig()
         self._available_checks = self._discover_checks()
+        self._performance_target = 30.0  # <30s target for cfat assessments
+        self._assessment_start_time = None
+        
+        console.print(Panel(
+            f"[green]✅ Cloud Foundations Assessment initialized[/green]\n"
+            f"[white]Profile: {self.profile or 'default'}[/white]\n"
+            f"[white]Region: {self.region}[/white]\n"
+            f"[white]Available checks: {len(self._available_checks)}[/white]",
+            title="🔍 CFAT Assessment Engine",
+            border_style="blue"
+        ))
 
     def _discover_checks(self) -> Dict[str, type]:
         """Discover available assessment checks."""
@@ -153,23 +187,33 @@ class CloudFoundationsAssessment(CloudFoundationsBase):
         Returns:
             Assessment report with results
         """
-        logger.info("Starting Cloud Foundations assessment")
-        start_time = time.time()
+        # Performance benchmark start
+        self._assessment_start_time = time.time()
+        console.print(Panel(
+            "[cyan]🚀 Starting Cloud Foundations assessment...[/cyan]",
+            title="🔍 CFAT Assessment",
+            border_style="cyan"
+        ))
 
         try:
             # Get account information
             account_id = self.get_account_id()
             region = self.region or "us-east-1"
+            console.print(f"[blue]📋 Account: {account_id} | Region: {region}[/blue]")
 
             # Determine which checks to run
             checks_to_run = self._get_checks_to_run()
-            logger.info(f"Running {len(checks_to_run)} assessment checks")
+            console.print(f"[green]🔍 Running {len(checks_to_run)} assessment checks[/green]")
 
-            # Execute checks
-            results = self._execute_checks(checks_to_run)
+            # Execute checks with Rich CLI progress
+            results = self._execute_checks_enhanced(checks_to_run)
 
-            # Generate summary
-            summary = self._generate_summary(results, time.time() - start_time)
+            # Performance benchmark end
+            elapsed_time = time.time() - self._assessment_start_time
+            self._display_performance_results(elapsed_time, len(checks_to_run))
+
+            # Generate summary  
+            summary = self._generate_summary(results, elapsed_time)
 
             # Create report
             report = AssessmentReport(
@@ -382,6 +426,73 @@ class CloudFoundationsAssessment(CloudFoundationsBase):
             total_execution_time=total_time,
         )
 
+    def _execute_checks_enhanced(self, checks: List[str]) -> List[AssessmentResult]:
+        """Execute checks with Rich CLI progress display."""
+        results = []
+        
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+            TimeElapsedColumn(),
+            console=console
+        ) as progress:
+            task = progress.add_task(f"[cyan]Executing assessments...", total=len(checks))
+
+            for check_name in checks:
+                progress.update(task, description=f"[cyan]Running check: {check_name}")
+                
+                try:
+                    result = self._execute_single_check(check_name)
+                    results.append(result)
+                    
+                    # Status indicator
+                    if result.status == CheckStatus.PASS:
+                        status_emoji = "✅"
+                        status_color = "green"
+                    elif result.status == CheckStatus.FAIL:
+                        status_emoji = "❌"
+                        status_color = "red" 
+                    elif result.status == CheckStatus.SKIP:
+                        status_emoji = "⏭️"
+                        status_color = "yellow"
+                    else:
+                        status_emoji = "⚠️"
+                        status_color = "orange"
+                        
+                    progress.update(task, description=f"[{status_color}]{status_emoji} {check_name}[/{status_color}]")
+                    
+                except Exception as e:
+                    result = self._create_error_result(check_name, str(e))
+                    results.append(result)
+                    progress.update(task, description=f"[red]⚠️ Error in {check_name}[/red]")
+                
+                progress.advance(task)
+        
+        return results
+
+    def _display_performance_results(self, elapsed_time: float, check_count: int) -> None:
+        """Display assessment performance results with Rich CLI."""
+        # Performance validation against target
+        if elapsed_time <= self._performance_target:
+            console.print(f"[green]⚡ Assessment completed in {elapsed_time:.2f}s (target: {self._performance_target}s) ✅[/green]")
+        else:
+            console.print(f"[yellow]⚠️  Assessment completed in {elapsed_time:.2f}s (exceeded target: {self._performance_target}s)[/yellow]")
+        
+        # Performance metrics table
+        metrics_table = Table(title="📊 Performance Metrics")
+        metrics_table.add_column("Metric", style="cyan")
+        metrics_table.add_column("Value", style="magenta")
+        metrics_table.add_column("Target", style="green")
+        
+        avg_check_time = elapsed_time / check_count if check_count > 0 else 0
+        metrics_table.add_row("Total Time", f"{elapsed_time:.2f}s", f"<{self._performance_target}s")
+        metrics_table.add_row("Check Count", str(check_count), "N/A")
+        metrics_table.add_row("Avg per Check", f"{avg_check_time:.2f}s", "<1s")
+        
+        console.print(metrics_table)
+
     def run(self):
         """Implementation of abstract base method."""
         return self.run_assessment()

runbooks/cfat/models.py

@@ -240,8 +240,12 @@ class AssessmentSummary(BaseModel):
             total_execution_time=45.5
         )
 
-        print(f"Pass rate: {summary.pass_rate:.1f}%")
-        print(f"Compliance score: {summary.compliance_score}")
+        # Rich console output for better formatting
+        from rich.console import Console
+        console = Console()
+        
+        console.print(f"[green]Pass rate: {summary.pass_rate:.1f}%[/green]")
+        console.print(f"[blue]Compliance score: {summary.compliance_score}[/blue]")
         ```
     """
 

runbooks/common/logger.py

@@ -0,0 +1,14 @@
+# Enterprise Logger - Common Interface
+# Re-export logger functionality for consistent imports
+
+from runbooks.utils.logger import configure_logger
+
+
+# Standard interface for enterprise logging
+def get_logger(module_name: str):
+    """Get configured logger for module - enterprise standard interface."""
+    return configure_logger(module_name)
+
+
+# Backward compatibility exports
+__all__ = ["get_logger", "configure_logger"]

runbooks/common/rich_utils.py

@@ -0,0 +1,451 @@
+#!/usr/bin/env python3
+"""
+Rich Library Utilities for CloudOps Runbooks Platform
+
+This module provides centralized Rich components and styling for consistent,
+beautiful terminal output across all CloudOps Runbooks modules.
+
+Features:
+- Custom CloudOps theme and color schemes
+- Reusable UI components (headers, footers, panels)
+- Standard progress bars and spinners
+- Consistent table styles
+- Error/warning/success message formatting
+- Tree displays for hierarchical data
+- Layout templates for complex displays
+
+Author: CloudOps Runbooks Team
+Version: 0.7.8
+"""
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
+
+from rich import box
+from rich.columns import Columns
+from rich.console import Console
+from rich.layout import Layout
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, SpinnerColumn, TaskProgressColumn, TextColumn, TimeElapsedColumn
+from rich.rule import Rule
+from rich.style import Style
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.text import Text
+from rich.theme import Theme
+from rich.tree import Tree
+
+# CloudOps Custom Theme
+CLOUDOPS_THEME = Theme(
+    {
+        "info": "cyan",
+        "success": "green bold",
+        "warning": "yellow bold",
+        "error": "red bold",
+        "critical": "red bold reverse",
+        "highlight": "bright_blue bold",
+        "header": "bright_cyan bold",
+        "subheader": "cyan",
+        "dim": "dim white",
+        "resource": "bright_magenta",
+        "cost": "bright_green",
+        "security": "bright_red",
+        "compliance": "bright_yellow",
+    }
+)
+
+# Initialize console with custom theme
+console = Console(theme=CLOUDOPS_THEME)
+
+# Status indicators
+STATUS_INDICATORS = {
+    "success": "🟢",
+    "warning": "🟡",
+    "error": "🔴",
+    "info": "🔵",
+    "pending": "⚪",
+    "running": "🔄",
+    "stopped": "⏹️",
+    "critical": "🚨",
+}
+
+
+def get_console() -> Console:
+    """Get the themed console instance."""
+    return console
+
+
+def print_header(title: str, version: str = "0.7.8") -> None:
+    """
+    Print a consistent header for all modules.
+
+    Args:
+        title: Module title
+        version: Module version
+    """
+    header_text = Text()
+    header_text.append("CloudOps Runbooks ", style="header")
+    header_text.append(f"| {title} ", style="subheader")
+    header_text.append(f"v{version}", style="dim")
+
+    console.print()
+    console.print(Panel(header_text, box=box.DOUBLE, style="header"))
+    console.print()
+
+
+def print_banner() -> None:
+    """Print the CloudOps Runbooks ASCII banner."""
+    banner = r"""
+    ╔═══════════════════════════════════════════════════════════════╗
+    ║   _____ _                 _  ____              ____            ║
+    ║  / ____| |               | |/ __ \            |  _ \           ║
+    ║ | |    | | ___  _   _  __| | |  | |_ __  ___  | |_) |_   _ __ ║
+    ║ | |    | |/ _ \| | | |/ _` | |  | | '_ \/ __| |  _ <| | | '_ \ ║
+    ║ | |____| | (_) | |_| | (_| | |__| | |_) \__ \ | |_) | |_| | | |║
+    ║  \_____|_|\___/ \__,_|\__,_|\____/| .__/|___/ |____/ \__,_|_| |║
+    ║                                   | |                          ║
+    ║   Enterprise AWS Automation      |_|         Platform v0.7.8   ║
+    ╚═══════════════════════════════════════════════════════════════╝
+    """
+    console.print(banner, style="header")
+
+
+def create_table(
+    title: Optional[str] = None,
+    columns: List[Dict[str, Any]] = None,
+    show_header: bool = True,
+    show_footer: bool = False,
+    box_style: Any = box.ROUNDED,
+    title_style: str = "header",
+) -> Table:
+    """
+    Create a consistent styled table.
+
+    Args:
+        title: Table title
+        columns: List of column definitions [{"name": "Col1", "style": "cyan", "justify": "left"}]
+        show_header: Show header row
+        show_footer: Show footer row
+        box_style: Rich box style
+        title_style: Style for title
+
+    Returns:
+        Configured Table object
+    """
+    table = Table(
+        title=title,
+        show_header=show_header,
+        show_footer=show_footer,
+        box=box_style,
+        title_style=title_style,
+        header_style="bold",
+        row_styles=["none", "dim"],  # Alternating row colors
+    )
+
+    if columns:
+        for col in columns:
+            table.add_column(
+                col.get("name", ""),
+                style=col.get("style", ""),
+                justify=col.get("justify", "left"),
+                no_wrap=col.get("no_wrap", False),
+            )
+
+    return table
+
+
+def create_progress_bar(description: str = "Processing") -> Progress:
+    """
+    Create a consistent progress bar.
+
+    Args:
+        description: Progress bar description
+
+    Returns:
+        Configured Progress object
+    """
+    return Progress(
+        SpinnerColumn(spinner_name="dots", style="cyan"),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(bar_width=40, style="cyan", complete_style="green"),
+        TaskProgressColumn(),
+        TimeElapsedColumn(),
+        console=console,
+        transient=True,
+    )
+
+
+def print_status(message: str, status: str = "info") -> None:
+    """
+    Print a status message with appropriate styling and indicator.
+
+    Args:
+        message: Status message
+        status: Status type (success, warning, error, info, critical)
+    """
+    indicator = STATUS_INDICATORS.get(status, "")
+    style = status if status in ["success", "warning", "error", "critical", "info"] else "info"
+    console.print(f"{indicator} {message}", style=style)
+
+
+def print_error(message: str, exception: Optional[Exception] = None) -> None:
+    """
+    Print an error message with optional exception details.
+
+    Args:
+        message: Error message
+        exception: Optional exception object
+    """
+    console.print(f"{STATUS_INDICATORS['error']} {message}", style="error")
+    if exception:
+        console.print(f"    Details: {str(exception)}", style="dim")
+
+
+def print_success(message: str) -> None:
+    """
+    Print a success message.
+
+    Args:
+        message: Success message
+    """
+    console.print(f"{STATUS_INDICATORS['success']} {message}", style="success")
+
+
+def print_warning(message: str) -> None:
+    """
+    Print a warning message.
+
+    Args:
+        message: Warning message
+    """
+    console.print(f"{STATUS_INDICATORS['warning']} {message}", style="warning")
+
+
+def print_info(message: str) -> None:
+    """
+    Print an info message.
+
+    Args:
+        message: Info message
+    """
+    console.print(f"{STATUS_INDICATORS['info']} {message}", style="info")
+
+
+def create_tree(label: str, style: str = "cyan") -> Tree:
+    """
+    Create a tree for hierarchical display.
+
+    Args:
+        label: Root label
+        style: Tree style
+
+    Returns:
+        Tree object
+    """
+    return Tree(label, style=style, guide_style="dim")
+
+
+def print_separator(label: Optional[str] = None, style: str = "dim") -> None:
+    """
+    Print a separator line.
+
+    Args:
+        label: Optional label for separator
+        style: Separator style
+    """
+    if label:
+        console.print(Rule(label, style=style))
+    else:
+        console.print(Rule(style=style))
+
+
+def create_panel(
+    content: Any,
+    title: Optional[str] = None,
+    subtitle: Optional[str] = None,
+    border_style: str = "cyan",
+    padding: int = 1,
+) -> Panel:
+    """
+    Create a panel for highlighting content.
+
+    Args:
+        content: Panel content
+        title: Panel title
+        subtitle: Panel subtitle
+        border_style: Border color/style
+        padding: Internal padding
+
+    Returns:
+        Panel object
+    """
+    return Panel(
+        content, title=title, subtitle=subtitle, border_style=border_style, padding=(padding, padding), expand=False
+    )
+
+
+def format_cost(amount: float, currency: str = "USD") -> Text:
+    """
+    Format a cost value with appropriate styling.
+
+    Args:
+        amount: Cost amount
+        currency: Currency code
+
+    Returns:
+        Formatted Text object
+    """
+    text = Text()
+    symbol = "$" if currency == "USD" else currency
+    if amount >= 10000:
+        text.append(f"{symbol}{amount:,.2f}", style="cost bold")
+    elif amount >= 1000:
+        text.append(f"{symbol}{amount:,.2f}", style="cost")
+    else:
+        text.append(f"{symbol}{amount:,.2f}", style="dim")
+    return text
+
+
+def format_resource_count(count: int, resource_type: str) -> Text:
+    """
+    Format a resource count with appropriate styling.
+
+    Args:
+        count: Resource count
+        resource_type: Type of resource
+
+    Returns:
+        Formatted Text object
+    """
+    text = Text()
+    if count == 0:
+        text.append(f"{count} {resource_type}", style="dim")
+    elif count > 100:
+        text.append(f"{count} {resource_type}", style="warning")
+    else:
+        text.append(f"{count} {resource_type}", style="resource")
+    return text
+
+
+def create_layout(sections: Dict[str, Any]) -> Layout:
+    """
+    Create a layout for complex displays.
+
+    Args:
+        sections: Dictionary of layout sections
+
+    Returns:
+        Layout object
+    """
+    layout = Layout()
+
+    # Example layout structure
+    if "header" in sections:
+        layout.split_column(Layout(name="header", size=3), Layout(name="body"), Layout(name="footer", size=3))
+        layout["header"].update(sections["header"])
+
+    if "body" in sections:
+        if isinstance(sections["body"], dict):
+            layout["body"].split_row(*[Layout(name=k) for k in sections["body"].keys()])
+            for key, content in sections["body"].items():
+                layout["body"][key].update(content)
+        else:
+            layout["body"].update(sections["body"])
+
+    if "footer" in sections:
+        layout["footer"].update(sections["footer"])
+
+    return layout
+
+
+def print_json(data: Dict[str, Any], title: Optional[str] = None) -> None:
+    """
+    Print JSON data with syntax highlighting.
+
+    Args:
+        data: JSON data to display
+        title: Optional title
+    """
+    import json
+
+    json_str = json.dumps(data, indent=2)
+    syntax = Syntax(json_str, "json", theme="monokai", line_numbers=False)
+    if title:
+        console.print(Panel(syntax, title=title, border_style="cyan"))
+    else:
+        console.print(syntax)
+
+
+def print_markdown(text: str) -> None:
+    """
+    Print markdown formatted text.
+
+    Args:
+        text: Markdown text
+    """
+    md = Markdown(text)
+    console.print(md)
+
+
+def confirm_action(prompt: str, default: bool = False) -> bool:
+    """
+    Get user confirmation with styled prompt.
+
+    Args:
+        prompt: Confirmation prompt
+        default: Default value if user just presses enter
+
+    Returns:
+        User's confirmation choice
+    """
+    default_text = "[Y/n]" if default else "[y/N]"
+    console.print(f"\n{STATUS_INDICATORS['info']} {prompt} {default_text}: ", style="info", end="")
+
+    response = input().strip().lower()
+    if not response:
+        return default
+    return response in ["y", "yes"]
+
+
+def create_columns(items: List[Any], equal: bool = True, expand: bool = True) -> Columns:
+    """
+    Create columns for side-by-side display.
+
+    Args:
+        items: List of items to display in columns
+        equal: Equal width columns
+        expand: Expand to full width
+
+    Returns:
+        Columns object
+    """
+    return Columns(items, equal=equal, expand=expand, padding=(0, 2))
+
+
+# Export all public functions and constants
+__all__ = [
+    "CLOUDOPS_THEME",
+    "STATUS_INDICATORS",
+    "console",
+    "get_console",
+    "print_header",
+    "print_banner",
+    "create_table",
+    "create_progress_bar",
+    "print_status",
+    "print_error",
+    "print_success",
+    "print_warning",
+    "print_info",
+    "create_tree",
+    "print_separator",
+    "create_panel",
+    "format_cost",
+    "format_resource_count",
+    "create_layout",
+    "print_json",
+    "print_markdown",
+    "confirm_action",
+    "create_columns",
+]