aegis-stack 0.2.0rc2__py3-none-any.whl

aegis/templates/copier-aegis-project/{{ project_slug }}/app/components/frontend/dashboard/cards/redis_card.py

@@ -0,0 +1,322 @@
+"""
+Stunning Redis/Cache Component Card
+
+Modern, visually striking card component that displays real Redis metrics
+from Redis INFO command, including memory usage, cache hit rates, operations
+per second, connection statistics, and comprehensive performance data.
+"""
+
+import flet as ft
+from app.components.frontend.controls import (
+    LabelText,
+    MetricText,
+    PrimaryText,
+    SecondaryText,
+    TitleText,
+)
+from app.services.system.models import ComponentStatus, ComponentStatusType
+
+from .card_utils import create_responsive_3_section_layout
+
+
+class RedisCard:
+    """
+    A visually stunning, wide component card for displaying real Redis metrics.
+
+    Features:
+    - Modern Material Design 3 styling with circular gauge indicators
+    - Three-section layout (badge, real-time metrics, performance stats)
+    - Real Redis INFO command data: hit rates, memory usage, ops/sec
+    - Comprehensive statistics: uptime, keys, connections, evictions
+    - Health-aware coloring based on cache performance thresholds
+    - Graceful fallback for unavailable metrics
+    """
+
+    def __init__(self, component_data: ComponentStatus) -> None:
+        """
+        Initialize the Redis card with component data.
+
+        Args:
+            component_data: ComponentStatus containing Redis health and metrics
+        """
+        self.component_data = component_data
+        self._card_container: ft.Container | None = None
+
+    def _get_status_colors(self) -> tuple[str, str, str]:
+        """
+        Get status-aware colors for the card.
+
+        Returns:
+            Tuple of (primary_color, background_color, border_color)
+        """
+        status = self.component_data.status
+
+        if status == ComponentStatusType.HEALTHY:
+            return (ft.Colors.GREEN, ft.Colors.SURFACE, ft.Colors.GREEN)
+        elif status == ComponentStatusType.INFO:
+            return (ft.Colors.BLUE, ft.Colors.SURFACE, ft.Colors.BLUE)
+        elif status == ComponentStatusType.WARNING:
+            return (ft.Colors.ORANGE, ft.Colors.SURFACE, ft.Colors.ORANGE)
+        else:  # UNHEALTHY
+            return (ft.Colors.RED, ft.Colors.SURFACE, ft.Colors.RED)
+
+    def _create_metric_gauge(
+        self, label: str, value: float, unit: str, color: str
+    ) -> ft.Container:
+        """Create a circular gauge-style metric indicator."""
+        # Format value appropriately based on size
+        if value >= 1000:
+            formatted_value = f"{value / 1000:.1f}k"
+        elif value >= 1000000:
+            formatted_value = f"{value / 1000000:.1f}M"
+        else:
+            formatted_value = (
+                f"{value:.1f}" if isinstance(value, float) else str(int(value))
+            )
+
+        return ft.Container(
+            content=ft.Column(
+                [
+                    LabelText(label),
+                    ft.Container(
+                        content=ft.Column(
+                            [
+                                MetricText(formatted_value),
+                                LabelText(unit),
+                            ],
+                            alignment=ft.MainAxisAlignment.CENTER,
+                            horizontal_alignment=ft.CrossAxisAlignment.CENTER,
+                            spacing=0,
+                        ),
+                        width=60,
+                        height=60,
+                        bgcolor=ft.Colors.with_opacity(0.1, color),
+                        border=ft.border.all(2, color),
+                        border_radius=30,
+                        padding=ft.padding.all(4),
+                    ),
+                ],
+                alignment=ft.MainAxisAlignment.CENTER,
+                horizontal_alignment=ft.CrossAxisAlignment.CENTER,
+                spacing=4,
+            ),
+            padding=ft.padding.all(8),
+        )
+
+    def _create_technology_badge(self) -> ft.Container:
+        """Create the Redis technology badge section."""
+        primary_color, _, _ = self._get_status_colors()
+
+        return ft.Container(
+            content=ft.Column(
+                [
+                    ft.Container(
+                        content=ft.Text("🗄️", size=32),
+                        padding=ft.padding.all(8),
+                        bgcolor=primary_color,
+                        border_radius=12,
+                        margin=ft.margin.only(bottom=8),
+                    ),
+                    TitleText("Redis"),
+                    SecondaryText("Cache + Pub/Sub"),
+                    ft.Container(
+                        content=LabelText(
+                            "CACHE",
+                            color=ft.Colors.WHITE,
+                        ),
+                        padding=ft.padding.symmetric(horizontal=8, vertical=2),
+                        bgcolor=ft.Colors.RED,
+                        border_radius=8,
+                        margin=ft.margin.only(top=4),
+                    ),
+                ],
+                alignment=ft.MainAxisAlignment.CENTER,
+                horizontal_alignment=ft.CrossAxisAlignment.CENTER,
+                spacing=4,
+            ),
+            padding=ft.padding.all(16),
+            width=160,  # Expanded badge width to 160px
+        )
+
+    def _create_metrics_section(self) -> ft.Container:
+        """Create the Redis metrics section with memory and connection stats."""
+        # Extract real Redis metrics from component metadata
+        metadata = self.component_data.metadata or {}
+
+        # Calculate hit rate with proper color coding
+        hit_rate = metadata.get("hit_rate_percent", 0)
+        hit_rate_color = (
+            ft.Colors.GREEN
+            if hit_rate >= 90
+            else ft.Colors.ORANGE
+            if hit_rate >= 70
+            else ft.Colors.RED
+        )
+
+        # Calculate memory usage percentage if maxmemory is set
+        used_memory = metadata.get("used_memory", 0)
+        max_memory = metadata.get("maxmemory", 0)
+
+        if max_memory > 0:
+            memory_percent = (used_memory / max_memory) * 100
+            memory_value = memory_percent
+            memory_unit = "%"
+            # Set color based on memory usage percentage
+            if memory_percent >= 90:
+                memory_color = ft.Colors.RED
+            elif memory_percent >= 70:
+                memory_color = ft.Colors.ORANGE
+            else:
+                memory_color = ft.Colors.BLUE
+        else:
+            # Show absolute memory usage in MB
+            memory_value = used_memory / (1024 * 1024) if used_memory > 0 else 0
+            memory_unit = "MB"
+            memory_color = ft.Colors.BLUE
+
+        # Get operations per second
+        ops_per_sec = metadata.get("instantaneous_ops_per_sec", 0)
+
+        redis_metrics = {
+            "hit_ratio": {
+                "value": hit_rate,
+                "unit": "%",
+                "color": hit_rate_color,
+            },
+            "memory": {
+                "value": memory_value,
+                "unit": memory_unit,
+                "color": memory_color,
+            },
+            "ops_sec": {
+                "value": ops_per_sec,
+                "unit": "/sec",
+                "color": ft.Colors.PURPLE,
+            },
+        }
+
+        metrics_controls = []
+        for metric_key, data in redis_metrics.items():
+            label = metric_key.replace("_", " ").replace("ops sec", "Ops").title()
+            metrics_controls.append(
+                self._create_metric_gauge(
+                    label,
+                    data["value"],
+                    data["unit"],
+                    data["color"],
+                )
+            )
+
+        return ft.Column(
+            [
+                PrimaryText("Cache Metrics"),
+                ft.Divider(height=1, color=ft.Colors.GREY_300),
+                ft.Row(
+                    metrics_controls, spacing=15, alignment=ft.MainAxisAlignment.CENTER
+                ),
+            ],
+            spacing=8,
+        )
+
+    def _create_performance_section(self) -> ft.Container:
+        """Create the Redis performance and statistics section."""
+
+        # Extract real Redis performance stats from metadata
+        metadata = self.component_data.metadata or {}
+
+        # Format uptime from seconds to human readable
+        uptime_seconds = metadata.get("uptime_in_seconds", 0)
+        uptime_days = uptime_seconds // 86400
+        uptime_hours = (uptime_seconds % 86400) // 3600
+        uptime_str = (
+            f"{uptime_days}d {uptime_hours}h" if uptime_days > 0 else f"{uptime_hours}h"
+        )
+
+        # Format numbers with commas
+        def format_number(num: int | float) -> str:
+            if isinstance(num, float):
+                return f"{num:,.1f}"
+            return f"{num:,}"
+
+        performance_stats = {
+            "Uptime": uptime_str,
+            "Commands/sec": format_number(metadata.get("instantaneous_ops_per_sec", 0)),
+            "Total Keys": format_number(metadata.get("total_keys", 0)),
+            "Memory Peak": metadata.get("used_memory_peak_human", "unknown"),
+            "Connected Clients": format_number(metadata.get("connected_clients", 0)),
+            "Evicted Keys": format_number(metadata.get("evicted_keys", 0)),
+            "Fragmentation": f"{metadata.get('mem_fragmentation_ratio', 1.0):.2f}",
+        }
+
+        perf_content = [
+            PrimaryText("Performance"),
+            ft.Divider(height=1, color=ft.Colors.GREY_300),
+        ]
+
+        for stat_name, stat_value in performance_stats.items():
+            perf_content.append(
+                ft.Row(
+                    [
+                        SecondaryText(f"{stat_name}:"),
+                        LabelText(stat_value),
+                    ],
+                    alignment=ft.MainAxisAlignment.SPACE_BETWEEN,
+                )
+            )
+
+        # Add status info
+        perf_content.extend(
+            [
+                ft.Divider(height=1, color=ft.Colors.GREY_300),
+                ft.Row(
+                    [
+                        SecondaryText("Status:"),
+                        LabelText(
+                            self.component_data.status.value.title(),
+                            color=self._get_status_colors()[0],
+                        ),
+                    ],
+                    alignment=ft.MainAxisAlignment.SPACE_BETWEEN,
+                ),
+            ]
+        )
+
+        # Wrap in a scrollable container to handle overflow
+        return ft.Container(
+            content=ft.Column(
+                [
+                    ft.Container(
+                        content=ft.Column(
+                            perf_content,
+                            spacing=6,
+                            scroll=ft.ScrollMode.AUTO,
+                        ),
+                        height=240,  # Increased height to show more stats
+                    )
+                ]
+            ),
+            padding=ft.padding.only(right=4),  # Add padding for scrollbar space
+        )
+
+    def build(self) -> ft.Container:
+        """Build and return the complete Redis card with responsive layout."""
+        primary_color, background_color, border_color = self._get_status_colors()
+
+        # Use shared responsive 3-section layout prioritizing middle section
+        content = create_responsive_3_section_layout(
+            left_content=self._create_technology_badge(),
+            middle_content=self._create_metrics_section(),
+            right_content=self._create_performance_section(),
+        )
+
+        self._card_container = ft.Container(
+            content=content,
+            bgcolor=ft.Colors.SURFACE,
+            border=ft.border.all(1, border_color),
+            border_radius=16,
+            padding=0,
+            width=None,  # Let ResponsiveRow handle the width
+            height=280,
+        )
+
+        return self._card_container

aegis/templates/copier-aegis-project/{{ project_slug }}/app/components/frontend/dashboard/cards/scheduler_card.py

@@ -0,0 +1,352 @@
+"""
+Stunning Scheduler Component Card
+
+Modern, visually striking card component that displays scheduled jobs,
+job statistics, and scheduling information using shared utility functions.
+"""
+
+from datetime import UTC
+
+import flet as ft
+from app.components.frontend.controls import PrimaryText
+from app.services.system.models import ComponentStatus
+
+from .card_utils import (
+    create_hover_handler,
+    create_responsive_3_section_layout,
+    create_standard_card_container,
+    create_stats_row,
+    create_tech_badge,
+    get_status_colors,
+)
+
+
+class SchedulerCard:
+    """
+    Visually stunning, wide component card for displaying Scheduler/APScheduler metrics.
+
+    Features:
+    - Modern Material Design 3 styling
+    - Three-section layout (badge, jobs, stats)
+    - Scheduled job indicators with next run times
+    - Job statistics and scheduler status
+    - Status-aware coloring and hover effects
+    - 800px width for optimal content spacing
+    """
+
+    def __init__(self, component_data: ComponentStatus) -> None:
+        """
+        Initialize the Scheduler card with component data.
+
+        Args:
+            component_data: ComponentStatus containing scheduler health and metrics
+        """
+        self.component_data = component_data
+        self._card_container: ft.Container | None = None
+
+    def _format_next_run_time(self, iso_time_str: str) -> str:
+        """Format ISO datetime string to human readable relative time."""
+        if not iso_time_str:
+            return "Unknown"
+
+        try:
+            from datetime import datetime
+
+            # Handle both timezone-aware and naive datetimes
+            if iso_time_str.endswith("Z"):
+                next_run = datetime.fromisoformat(iso_time_str.replace("Z", "+00:00"))
+            elif "+" in iso_time_str or iso_time_str.endswith("00:00"):
+                next_run = datetime.fromisoformat(iso_time_str)
+            else:
+                # Assume UTC if no timezone info
+                next_run = datetime.fromisoformat(iso_time_str).replace(tzinfo=UTC)
+
+            now = datetime.now(UTC)
+
+            # Make sure both datetimes are timezone-aware
+            if next_run.tzinfo is None:
+                next_run = next_run.replace(tzinfo=UTC)
+
+            delta = next_run - now
+            total_seconds = delta.total_seconds()
+
+            if total_seconds < 0:
+                return "Past due"
+            elif total_seconds < 60:
+                return f"in {int(total_seconds)}s"
+            elif total_seconds < 3600:
+                minutes = int(total_seconds / 60)
+                return f"in {minutes}m"
+            elif total_seconds < 86400:
+                hours = total_seconds / 3600
+                if hours < 2:
+                    return f"in {hours:.1f}h"
+                else:
+                    return f"in {int(hours)}h"
+            else:
+                days = int(total_seconds / 86400)
+                return f"in {days}d"
+        except Exception:
+            return "Unknown"
+
+    def _format_schedule_human_readable(self, schedule: str) -> str:
+        """Convert schedule format to human readable."""
+        if not schedule or "Unknown" in schedule:
+            return "Unknown schedule"
+
+        # Handle common cron patterns
+        if "hour=2, minute=0, second=0" in schedule:
+            return "Daily at 2:00 AM UTC"
+        elif "hour=" in schedule and "minute=" in schedule:
+            # Extract hour and minute from the schedule string
+            try:
+                import re
+
+                hour_match = re.search(r"hour=([0-9]+)", schedule)
+                minute_match = re.search(r"minute=([0-9]+)", schedule)
+                if hour_match and minute_match:
+                    hour = int(hour_match.group(1))
+                    minute = int(minute_match.group(1))
+                    time_str = f"{hour:02d}:{minute:02d}"
+                    return f"Daily at {time_str} UTC"
+            except Exception:
+                pass
+
+        # Fallback to original schedule
+        return schedule
+
+    def _handle_job_hover_simple(self, e: ft.ControlEvent) -> None:
+        """Simple hover handler that works with event source."""
+        container = e.control
+        buttons = container.content.controls[0].controls[2]  # Access the buttons row
+
+        if e.data == "true":  # Mouse enter
+            container.border = ft.border.all(1, ft.Colors.GREY_400)
+            buttons.opacity = 1.0
+        else:  # Mouse leave
+            container.border = ft.border.all(1, ft.Colors.TRANSPARENT)
+            buttons.opacity = 0.0
+        container.update()
+
+    def _create_technology_badge(self) -> ft.Container:
+        """Create the Scheduler technology badge section."""
+        primary_color, _, _ = get_status_colors(self.component_data)
+
+        return create_tech_badge(
+            title="Scheduler",
+            subtitle="APScheduler",
+            icon="⏰",
+            badge_text="JOBS",
+            badge_color=ft.Colors.TEAL,
+            primary_color=primary_color,
+            width=160,
+        )
+
+    def _create_jobs_section(self) -> ft.Container:
+        """Create the scheduled jobs section with job list."""
+        # Get real scheduled jobs from component metadata
+        upcoming_tasks = []
+        if (
+            self.component_data.metadata
+            and "upcoming_tasks" in self.component_data.metadata
+        ):
+            upcoming_tasks = self.component_data.metadata["upcoming_tasks"]
+
+        job_list_items = []
+        for task in upcoming_tasks:
+            # Format next run time
+            next_run_display = self._format_next_run_time(task.get("next_run", ""))
+            schedule = task.get("schedule", "Unknown schedule")
+
+            job_list_items.append(
+                ft.Container(
+                    content=ft.Column(
+                        [
+                            ft.Row(
+                                [
+                                    ft.Icon(
+                                        ft.Icons.SCHEDULE, size=16, color=ft.Colors.GREY
+                                    ),
+                                    ft.Text(
+                                        task.get("name", task.get("id", "Unknown")),
+                                        size=15,
+                                        weight=ft.FontWeight.W_500,
+                                        color=ft.Colors.ON_SURFACE,
+                                        expand=True,
+                                    ),
+                                    ft.Row(
+                                        [
+                                            ft.IconButton(
+                                                icon=ft.Icons.PAUSE_CIRCLE_OUTLINE,
+                                                icon_size=16,
+                                                icon_color=ft.Colors.GREY,
+                                                tooltip="Pause job",
+                                                on_click=lambda _: None,
+                                                style=ft.ButtonStyle(
+                                                    padding=ft.padding.all(2),
+                                                ),
+                                            ),
+                                            ft.IconButton(
+                                                icon=ft.Icons.DELETE_OUTLINE,
+                                                icon_size=16,
+                                                icon_color=ft.Colors.GREY,
+                                                tooltip="Delete job",
+                                                on_click=lambda _: None,
+                                                style=ft.ButtonStyle(
+                                                    padding=ft.padding.all(2),
+                                                ),
+                                            ),
+                                        ],
+                                        spacing=0,
+                                        opacity=0.0,  # Hidden by default
+                                    ),
+                                ],
+                                spacing=8,
+                                alignment=ft.MainAxisAlignment.SPACE_BETWEEN,
+                            ),
+                            ft.Row(
+                                [
+                                    ft.Text(
+                                        next_run_display,
+                                        size=12,
+                                        color=ft.Colors.GREY,
+                                    ),
+                                    ft.Text("|", size=12, color=ft.Colors.GREY),
+                                    ft.Text(
+                                        self._format_schedule_human_readable(schedule),
+                                        size=12,
+                                        color=ft.Colors.GREY,
+                                    ),
+                                ],
+                                spacing=6,
+                            ),
+                        ],
+                        spacing=6,
+                    ),
+                    padding=ft.padding.symmetric(vertical=2, horizontal=8),
+                    border=ft.border.all(1, ft.Colors.TRANSPARENT),
+                    border_radius=8,
+                    on_hover=self._handle_job_hover_simple,
+                )
+            )
+
+        # Add placeholder if no jobs
+        if not job_list_items:
+            job_list_items.append(
+                ft.Container(
+                    content=ft.Row(
+                        [
+                            ft.Icon(
+                                ft.Icons.SCHEDULE_OUTLINED,
+                                size=20,
+                                color=ft.Colors.GREY,
+                            ),
+                            ft.Text("No active jobs", color=ft.Colors.GREY),
+                        ],
+                        spacing=8,
+                        alignment=ft.MainAxisAlignment.CENTER,
+                    ),
+                    padding=ft.padding.all(20),
+                    bgcolor=ft.Colors.with_opacity(0.05, ft.Colors.GREY),
+                    border_radius=12,
+                )
+            )
+
+        return ft.Container(
+            content=ft.Container(
+                content=ft.Column(
+                    job_list_items,
+                    spacing=2,
+                    scroll=ft.ScrollMode.AUTO,
+                ),
+                height=250,  # Fixed height to force scrolling
+                padding=ft.padding.all(
+                    0
+                ),  # Remove any default padding from inner container
+            ),
+            width=400,  # Section width
+            padding=ft.padding.only(left=12, right=12, bottom=12, top=0),
+            alignment=ft.alignment.top_left,
+        )
+
+    def _create_stats_section(self) -> ft.Container:
+        """Create the scheduler statistics section."""
+        # Get real scheduler stats from component metadata
+        metadata = self.component_data.metadata or {}
+
+        total_tasks = str(metadata.get("total_tasks", 0))
+        active_tasks = str(metadata.get("active_tasks", 0))
+        paused_tasks = str(metadata.get("paused_tasks", 0))
+
+        # Get next job info
+        upcoming_tasks = metadata.get("upcoming_tasks", [])
+        next_job = "None"
+        if upcoming_tasks:
+            next_job = self._format_next_run_time(upcoming_tasks[0].get("next_run", ""))
+
+        scheduler_stats = {
+            "Total Tasks": total_tasks,
+            "Active Tasks": active_tasks,
+            "Paused Tasks": paused_tasks,
+            "Next Task": next_job,
+        }
+
+        stats_content = [
+            PrimaryText("Task Statistics"),
+            ft.Divider(height=1, color=ft.Colors.GREY_300),
+        ]
+
+        # Add all stats using the utility function
+        for stat_name, stat_value in scheduler_stats.items():
+            stats_content.append(create_stats_row(stat_name, stat_value))
+
+        # Add scheduler status
+        stats_content.extend(
+            [
+                ft.Divider(height=1, color=ft.Colors.GREY_300),
+                create_stats_row(
+                    "Status",
+                    self.component_data.status.value.title(),
+                    get_status_colors(self.component_data)[0],
+                ),
+            ]
+        )
+
+        return ft.Container(
+            content=ft.Column(
+                stats_content,
+                spacing=8,
+                alignment=ft.MainAxisAlignment.START,
+            ),
+            padding=ft.padding.all(16),
+            width=240,  # Stats section width
+            alignment=ft.alignment.top_left,
+        )
+
+    def build(self) -> ft.Container:
+        """Build and return the complete Scheduler card with responsive layout."""
+        primary_color, background_color, border_color = get_status_colors(
+            self.component_data
+        )
+
+        # Use shared responsive 3-section layout prioritizing middle section
+        content = create_responsive_3_section_layout(
+            left_content=self._create_technology_badge(),
+            middle_content=self._create_jobs_section(),
+            right_content=self._create_stats_section(),
+        )
+
+        self._card_container = create_standard_card_container(
+            content=content,
+            primary_color=primary_color,
+            border_color=border_color,
+            width=None,  # Let ResponsiveRow handle the width
+            hover_handler=create_hover_handler(
+                None
+            ),  # Will set after container creation
+        )
+
+        # Set the hover handler with the actual container
+        # Hover effects disabled
+
+        return self._card_container