aegis-stack 0.2.0rc2__py3-none-any.whl

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

@@ -0,0 +1,328 @@
+"""
+Stunning FastAPI Component Card
+
+Modern, visually striking card component that displays rich FastAPI metrics
+and system performance data using shared utility functions.
+"""
+
+import flet as ft
+from app.components.frontend.controls import LabelText, PrimaryText
+from app.services.system.models import ComponentStatus
+
+from .card_utils import (
+    create_hover_handler,
+    create_progress_indicator,
+    create_standard_card_container,
+    create_stats_row,
+    create_tech_badge,
+    get_status_colors,
+)
+
+
+class FastAPICard:
+    """
+    A visually stunning, wide component card for displaying FastAPI metrics.
+
+    Features:
+    - Modern Material Design 3 styling
+    - Three-section layout (badge, metrics, details)
+    - Status-aware coloring and visual indicators
+    - Progress bars for CPU, Memory, and Disk usage
+    - Hover effects and proper elevation
+    - ee-toolset color system integration
+    """
+
+    def __init__(self, component_data: ComponentStatus) -> None:
+        """
+        Initialize the FastAPI card with component data.
+
+        Args:
+            component_data: ComponentStatus containing FastAPI health and metrics
+        """
+        self.component_data = component_data
+        self._card_container: ft.Container | None = None
+
+    # Removed _get_status_colors - now using shared utility function
+
+    def _create_tech_badge(self) -> ft.Container:
+        """Create the Backend API technology badge section."""
+        primary_color, _, _ = get_status_colors(self.component_data)
+
+        return create_tech_badge(
+            title="Backend",
+            subtitle="FastAPI",
+            icon="🚀",
+            badge_text="API",
+            badge_color=ft.Colors.GREEN,
+            primary_color=primary_color,
+            width=None,  # Let flex handle the width
+        )
+
+    def _create_metrics_section(self) -> ft.Container:
+        """Create the system metrics section with progress indicators."""
+        sub_components = self.component_data.sub_components
+
+        # Extract metrics from sub-components
+        cpu_data = sub_components.get("cpu")
+        memory_data = sub_components.get("memory")
+        disk_data = sub_components.get("disk")
+
+        metrics_controls = []
+
+        if cpu_data and cpu_data.metadata:
+            cpu_percent = cpu_data.metadata.get("percent_used", 0.0)
+            cpu_color = (
+                ft.Colors.GREEN
+                if cpu_percent < 70
+                else ft.Colors.ORANGE
+                if cpu_percent < 85
+                else ft.Colors.RED
+            )
+            metrics_controls.append(
+                create_progress_indicator(
+                    "CPU Usage",
+                    cpu_percent,
+                    f"{cpu_data.metadata.get('core_count', 'N/A')} cores",
+                    cpu_color,
+                )
+            )
+
+        if memory_data and memory_data.metadata:
+            memory_percent = memory_data.metadata.get("percent_used", 0.0)
+            total_gb = memory_data.metadata.get("total_gb", 0.0)
+            available_gb = memory_data.metadata.get("available_gb", 0.0)
+            used_gb = total_gb - available_gb  # Calculate used memory
+            memory_color = (
+                ft.Colors.GREEN
+                if memory_percent < 70
+                else ft.Colors.ORANGE
+                if memory_percent < 85
+                else ft.Colors.RED
+            )
+            metrics_controls.append(
+                create_progress_indicator(
+                    "Memory Usage",
+                    memory_percent,
+                    f"{used_gb:.1f}GB / {total_gb:.1f}GB",  # Used/total format
+                    memory_color,
+                )
+            )
+
+        if disk_data and disk_data.metadata:
+            disk_percent = disk_data.metadata.get("percent_used", 0.0)
+            total_gb = disk_data.metadata.get("total_gb", 0.0)
+            free_gb = disk_data.metadata.get("free_gb", 0.0)
+            disk_color = (
+                ft.Colors.GREEN
+                if disk_percent < 70
+                else ft.Colors.ORANGE
+                if disk_percent < 85
+                else ft.Colors.RED
+            )
+            metrics_controls.append(
+                create_progress_indicator(
+                    "Disk Usage",
+                    disk_percent,
+                    f"{free_gb:.1f}GB / {total_gb:.1f}GB",
+                    disk_color,
+                )
+            )
+
+        # Add middleware section
+        middleware_stack = self.component_data.metadata.get("middleware_stack", [])
+        security_count = self.component_data.metadata.get("security_count", 0)
+
+        if middleware_stack:
+            # Add divider between system metrics and middleware
+            if metrics_controls:
+                metrics_controls.append(ft.Divider(height=1, color=ft.Colors.GREY_400))
+
+            # Add middleware pipeline header
+            metrics_controls.append(PrimaryText("Middleware Pipeline"))
+
+            # Security middleware summary
+            if security_count > 0:
+                metrics_controls.append(
+                    create_stats_row(
+                        "Security", f"{security_count} layers", ft.Colors.GREEN
+                    )
+                )
+
+            # Middleware stack (in execution order, show first 5)
+            for idx, middleware in enumerate(middleware_stack[:5]):
+                mw_name = middleware.get("type", "Unknown")
+                order_indicator = f"{idx + 1}."
+
+                # Color coding for security middleware
+                is_security = middleware.get("is_security", False)
+                color = ft.Colors.GREEN if is_security else ft.Colors.GREY_600
+
+                metrics_controls.append(
+                    ft.Row(
+                        [
+                            LabelText(order_indicator, size=10, width=20),
+                            LabelText(
+                                mw_name,
+                                color=color,
+                                size=10,
+                                weight=ft.FontWeight.W_500
+                                if is_security
+                                else ft.FontWeight.NORMAL,
+                            ),
+                        ],
+                        spacing=5,
+                        tight=True,
+                    )
+                )
+
+            # Show "more" indicator if there are additional middleware
+            if len(middleware_stack) > 5:
+                metrics_controls.append(
+                    LabelText(
+                        f"+ {len(middleware_stack) - 5} more middleware",
+                        size=10,
+                        color=ft.Colors.GREY_500,
+                        italic=True,
+                    )
+                )
+
+        return ft.Column(
+            metrics_controls,
+            spacing=8,
+            scroll=ft.ScrollMode.AUTO,
+        )
+
+    def _create_details_section(self) -> ft.Container:
+        """Create the additional details section with real route data."""
+        metadata = self.component_data.metadata or {}
+
+        # Get real route and middleware data from metadata
+        routes_data = metadata.get("routes", [])
+        total_routes = metadata.get("total_routes", 0)
+        total_endpoints = metadata.get("total_endpoints", 0)
+        method_counts = metadata.get("method_counts", {})
+        route_groups = metadata.get("route_groups", {})
+        has_docs = metadata.get("has_docs", False)
+        total_middleware = metadata.get("total_middleware", 0)
+
+        details_content = [
+            PrimaryText("API Overview"),
+            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],
+            ),
+        ]
+
+        # Add route statistics
+        if total_routes > 0:
+            details_content.extend(
+                [
+                    create_stats_row("Routes", str(total_routes)),
+                    create_stats_row("Endpoints", str(total_endpoints)),
+                ]
+            )
+
+        # Add middleware count if available
+        if total_middleware > 0:
+            details_content.append(
+                create_stats_row("Middleware", f"{total_middleware} layers")
+            )
+
+        if total_routes > 0:
+            # Add method breakdown if available
+            if method_counts:
+                method_summary = ", ".join(
+                    [
+                        f"{count} {method}"
+                        for method, count in sorted(method_counts.items())
+                    ]
+                )
+                details_content.append(create_stats_row("Methods", method_summary))
+        else:
+            details_content.append(create_stats_row("Routes", "No routes found"))
+
+        # Add docs feature indicator if available
+        if has_docs:
+            details_content.append(create_stats_row("Features", "Docs"))
+
+        # Add route groups summary if available
+        if route_groups and total_routes > 0:
+            details_content.extend(
+                [
+                    ft.Divider(height=1, color=ft.Colors.GREY_300),
+                    PrimaryText("Route Groups"),
+                ]
+            )
+
+            # Show top route groups (max 4)
+            for group, count in sorted(
+                route_groups.items(), key=lambda x: x[1], reverse=True
+            )[:4]:
+                group_display = group if group != "root" else "/"
+                details_content.append(
+                    create_stats_row(f"{group_display}", f"{count} routes")
+                )
+
+        # Handle fallback case (no route data available)
+        elif not routes_data and metadata.get("fallback"):
+            details_content.extend(
+                [
+                    ft.Divider(height=1, color=ft.Colors.GREY_300),
+                    LabelText(
+                        "Route introspection unavailable", color=ft.Colors.ORANGE
+                    ),
+                    LabelText("Using fallback display", size=11),
+                ]
+            )
+
+        return ft.Column(details_content, spacing=6, scroll=ft.ScrollMode.AUTO)
+
+    def build(self) -> ft.Container:
+        """Build the complete FastAPI card with simple 3-section responsive layout."""
+        primary_color, background_color, border_color = get_status_colors(
+            self.component_data
+        )
+
+        # Responsive 3-section layout with flex ratios prioritizing middle
+        content = ft.Row(
+            [
+                # Left: Tech badge (flexible, can shrink to minimum)
+                ft.Container(
+                    content=self._create_tech_badge(),
+                    expand=2,  # ~20% of space, can shrink
+                    width=100,  # Minimum width to keep badge readable
+                ),
+                ft.VerticalDivider(width=1, color=ft.Colors.GREY_300),
+                # Middle: Metrics (PRIORITY - gets most space and protection)
+                ft.Container(
+                    content=self._create_metrics_section(),
+                    expand=5,  # ~50% of space, PRIORITY SECTION
+                    padding=ft.padding.all(16),
+                    width=300,  # Minimum width to keep metrics functional
+                ),
+                ft.VerticalDivider(width=1, color=ft.Colors.GREY_300),
+                # Right: Details (flexible, shrinks most aggressively)
+                ft.Container(
+                    content=self._create_details_section(),
+                    expand=3,  # ~30% of space, can shrink aggressively
+                    padding=ft.padding.all(16),
+                    width=150,  # Minimum width to prevent complete disappearance
+                ),
+            ]
+        )
+
+        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
+        )
+
+        # Hover effects disabled
+
+        return self._card_container

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

@@ -0,0 +1,267 @@
+"""
+Flet Frontend Component Card
+
+Modern card component that displays Flet frontend framework information,
+UI settings, and frontend health status.
+"""
+
+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 FletCard:
+    """
+    Visually stunning component card for displaying Flet frontend metrics.
+
+    Features:
+    - Modern Material Design 3 styling
+    - Three-section layout (badge, settings, stats)
+    - Framework version and UI configuration
+    - Theme settings and refresh rates
+    - Status-aware coloring and hover effects
+    """
+
+    def __init__(self, component_data: ComponentStatus) -> None:
+        """
+        Initialize the Flet card with component data.
+
+        Args:
+            component_data: ComponentStatus containing frontend health and metrics
+        """
+        self.component_data = component_data
+        self._card_container: ft.Container | None = None
+
+    def _create_technology_badge(self) -> ft.Container:
+        """Create the Flet technology badge section."""
+        primary_color, _, _ = get_status_colors(self.component_data)
+
+        return create_tech_badge(
+            title="Frontend",
+            subtitle="Flet",
+            icon="🎨",
+            badge_text="UI",
+            badge_color=ft.Colors.PURPLE,
+            primary_color=primary_color,
+            width=160,
+        )
+
+    def _create_settings_section(self) -> ft.Container:
+        """Create the frontend settings section."""
+        # Get metadata
+        metadata = self.component_data.metadata or {}
+
+        settings_items = []
+
+        # Add framework info
+        settings_items.append(
+            ft.Container(
+                content=ft.Column(
+                    [
+                        ft.Row(
+                            [
+                                ft.Icon(ft.Icons.WEB, size=16, color=ft.Colors.GREY),
+                                ft.Text(
+                                    "Framework",
+                                    size=14,
+                                    weight=ft.FontWeight.W_500,
+                                    color=ft.Colors.ON_SURFACE,
+                                ),
+                            ],
+                            spacing=8,
+                        ),
+                        ft.Text(
+                            f"Flet {ft.version.version}",
+                            size=13,
+                            color=ft.Colors.GREY,
+                        ),
+                    ],
+                    spacing=4,
+                ),
+                padding=ft.padding.symmetric(vertical=8, horizontal=12),
+            )
+        )
+
+        # Add integration type
+        settings_items.append(
+            ft.Container(
+                content=ft.Column(
+                    [
+                        ft.Row(
+                            [
+                                ft.Icon(
+                                    ft.Icons.INTEGRATION_INSTRUCTIONS,
+                                    size=16,
+                                    color=ft.Colors.GREY,
+                                ),
+                                ft.Text(
+                                    "Integration",
+                                    size=14,
+                                    weight=ft.FontWeight.W_500,
+                                    color=ft.Colors.ON_SURFACE,
+                                ),
+                            ],
+                            spacing=8,
+                        ),
+                        ft.Text(
+                            metadata.get("note", "FastAPI integrated"),
+                            size=13,
+                            color=ft.Colors.GREY,
+                        ),
+                    ],
+                    spacing=4,
+                ),
+                padding=ft.padding.symmetric(vertical=8, horizontal=12),
+            )
+        )
+
+        # Add theme capabilities
+        settings_items.append(
+            ft.Container(
+                content=ft.Column(
+                    [
+                        ft.Row(
+                            [
+                                ft.Icon(
+                                    ft.Icons.PALETTE, size=16, color=ft.Colors.GREY
+                                ),
+                                ft.Text(
+                                    "Theme Support",
+                                    size=14,
+                                    weight=ft.FontWeight.W_500,
+                                    color=ft.Colors.ON_SURFACE,
+                                ),
+                            ],
+                            spacing=8,
+                        ),
+                        ft.Text(
+                            "Light / Dark Mode",
+                            size=13,
+                            color=ft.Colors.GREY,
+                        ),
+                    ],
+                    spacing=4,
+                ),
+                padding=ft.padding.symmetric(vertical=8, horizontal=12),
+            )
+        )
+
+        # Add refresh rate
+        settings_items.append(
+            ft.Container(
+                content=ft.Column(
+                    [
+                        ft.Row(
+                            [
+                                ft.Icon(
+                                    ft.Icons.REFRESH, size=16, color=ft.Colors.GREY
+                                ),
+                                ft.Text(
+                                    "Auto Refresh",
+                                    size=14,
+                                    weight=ft.FontWeight.W_500,
+                                    color=ft.Colors.ON_SURFACE,
+                                ),
+                            ],
+                            spacing=8,
+                        ),
+                        ft.Text(
+                            "Every 30 seconds",
+                            size=13,
+                            color=ft.Colors.GREY,
+                        ),
+                    ],
+                    spacing=4,
+                ),
+                padding=ft.padding.symmetric(vertical=8, horizontal=12),
+            )
+        )
+
+        return ft.Container(
+            content=ft.Column(
+                settings_items,
+                spacing=2,
+                scroll=ft.ScrollMode.AUTO,
+            ),
+            width=400,
+            height=250,
+            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 frontend statistics section."""
+        # Get metadata
+        metadata = self.component_data.metadata or {}
+
+        # Build stats
+        frontend_stats = {
+            "Framework": metadata.get("framework", "Flet").title(),
+            "UI Type": "Reactive Web",
+            "Platform": "Cross-platform",
+            "Components": "Material 3",
+        }
+
+        stats_content = [
+            PrimaryText("UI Configuration"),
+            ft.Divider(height=1, color=ft.Colors.GREY_300),
+        ]
+
+        # Add all stats
+        for stat_name, stat_value in frontend_stats.items():
+            stats_content.append(create_stats_row(stat_name, stat_value))
+
+        # Add 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,
+            alignment=ft.alignment.top_left,
+        )
+
+    def build(self) -> ft.Container:
+        """Build and return the complete Flet card with responsive layout."""
+        primary_color, background_color, border_color = get_status_colors(
+            self.component_data
+        )
+
+        # Use shared responsive 3-section layout
+        content = create_responsive_3_section_layout(
+            left_content=self._create_technology_badge(),
+            middle_content=self._create_settings_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),
+        )
+
+        return self._card_container