django-cfg 1.5.14__py3-none-any.whl → 1.5.29__py3-none-any.whl

django_cfg/apps/integrations/grpc/utils/handlers.py

@@ -0,0 +1,242 @@
+"""
+gRPC handler factory utilities.
+
+This module provides utilities for creating and registering gRPC servicers
+with proper error handling and logging.
+
+**Purpose**:
+Simplify the boilerplate code needed to register gRPC services with servers.
+
+**Usage Example**:
+```python
+from django_cfg.apps.integrations.grpc.utils.handlers import create_grpc_handler
+
+# Your servicer class
+class BotStreamingService(pb2_grpc.BotStreamingServiceServicer):
+    pass
+
+# Create handler tuple
+handlers = create_grpc_handler(
+    servicer_class=BotStreamingService,
+    add_servicer_func=pb2_grpc.add_BotStreamingServiceServicer_to_server,
+)
+
+# Use with django-cfg
+GRPC_HANDLERS = [handlers]
+```
+
+Created: 2025-11-07
+Status: %%PRODUCTION%%
+Phase: Phase 1 - Universal Components
+"""
+
+from typing import Callable, Tuple, Any, Optional, Type
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# Handler Factory
+# ============================================================================
+
+def create_grpc_handler(
+    servicer_class: Type,
+    add_servicer_func: Callable[[Any, Any], None],
+    servicer_kwargs: Optional[dict] = None,
+) -> Tuple[Callable[[Any, Any], None], Type, dict]:
+    """
+    Create gRPC handler tuple for django-cfg GRPC_HANDLERS.
+
+    This factory creates the standardized tuple format expected by django-cfg's
+    gRPC server initialization:
+    ```python
+    (add_servicer_function, servicer_class, init_kwargs)
+    ```
+
+    Args:
+        servicer_class: gRPC servicer class (e.g., MyStreamingService)
+        add_servicer_func: Generated add_*_to_server function from pb2_grpc
+        servicer_kwargs: Optional kwargs to pass to servicer constructor
+
+    Returns:
+        Tuple of (add_func, servicer_class, kwargs) for GRPC_HANDLERS
+
+    Example:
+    ```python
+    from .generated import bot_streaming_service_pb2_grpc
+    from .services import BotStreamingService
+
+    handlers = create_grpc_handler(
+        servicer_class=BotStreamingService,
+        add_servicer_func=bot_streaming_service_pb2_grpc.add_BotStreamingServiceServicer_to_server,
+        servicer_kwargs={'config': my_config},
+    )
+
+    # In settings.py
+    GRPC_HANDLERS = [handlers]
+    ```
+
+    **django-cfg Integration**:
+    The tuple is used by django-cfg like this:
+    ```python
+    for add_func, servicer_class, kwargs in GRPC_HANDLERS:
+        servicer = servicer_class(**kwargs)
+        add_func(servicer, server)
+    ```
+    """
+    kwargs = servicer_kwargs or {}
+
+    logger.debug(
+        f"Created gRPC handler: {servicer_class.__name__} "
+        f"with {len(kwargs)} init kwargs"
+    )
+
+    return (add_servicer_func, servicer_class, kwargs)
+
+
+def create_multiple_grpc_handlers(
+    handlers_config: list[dict],
+) -> list[Tuple[Callable[[Any, Any], None], Type, dict]]:
+    """
+    Create multiple gRPC handlers from configuration list.
+
+    Convenience function for creating multiple handlers at once.
+
+    Args:
+        handlers_config: List of handler configurations, each with keys:
+            - servicer_class: Servicer class
+            - add_servicer_func: Add function
+            - servicer_kwargs: Optional init kwargs
+
+    Returns:
+        List of handler tuples for GRPC_HANDLERS
+
+    Example:
+    ```python
+    handlers = create_multiple_grpc_handlers([
+        {
+            'servicer_class': BotStreamingService,
+            'add_servicer_func': pb2_grpc.add_BotStreamingServiceServicer_to_server,
+        },
+        {
+            'servicer_class': SignalStreamingService,
+            'add_servicer_func': signal_pb2_grpc.add_SignalStreamingServiceServicer_to_server,
+            'servicer_kwargs': {'timeout': 30},
+        },
+    ])
+
+    # In settings.py
+    GRPC_HANDLERS = handlers
+    ```
+    """
+    handlers = []
+
+    for config in handlers_config:
+        handler = create_grpc_handler(
+            servicer_class=config['servicer_class'],
+            add_servicer_func=config['add_servicer_func'],
+            servicer_kwargs=config.get('servicer_kwargs'),
+        )
+        handlers.append(handler)
+
+    logger.info(f"Created {len(handlers)} gRPC handlers")
+
+    return handlers
+
+
+# ============================================================================
+# Validation Utilities
+# ============================================================================
+
+def validate_grpc_handler(
+    handler: Tuple[Callable, Type, dict],
+) -> bool:
+    """
+    Validate that handler tuple has correct structure.
+
+    Args:
+        handler: Handler tuple to validate
+
+    Returns:
+        True if valid, False otherwise
+
+    Example:
+    ```python
+    handler = create_grpc_handler(MyService, add_func)
+
+    if validate_grpc_handler(handler):
+        GRPC_HANDLERS.append(handler)
+    ```
+    """
+    if not isinstance(handler, tuple):
+        logger.error(f"Handler must be tuple, got {type(handler)}")
+        return False
+
+    if len(handler) != 3:
+        logger.error(f"Handler tuple must have 3 elements, got {len(handler)}")
+        return False
+
+    add_func, servicer_class, kwargs = handler
+
+    if not callable(add_func):
+        logger.error(f"First element (add_func) must be callable, got {type(add_func)}")
+        return False
+
+    if not isinstance(servicer_class, type):
+        logger.error(f"Second element (servicer_class) must be class, got {type(servicer_class)}")
+        return False
+
+    if not isinstance(kwargs, dict):
+        logger.error(f"Third element (kwargs) must be dict, got {type(kwargs)}")
+        return False
+
+    return True
+
+
+def validate_grpc_handlers(
+    handlers: list,
+) -> Tuple[bool, list[str]]:
+    """
+    Validate list of handlers.
+
+    Args:
+        handlers: List of handler tuples
+
+    Returns:
+        Tuple of (all_valid: bool, errors: list[str])
+
+    Example:
+    ```python
+    valid, errors = validate_grpc_handlers(GRPC_HANDLERS)
+
+    if not valid:
+        for error in errors:
+            logger.error(error)
+        raise ValueError("Invalid gRPC handlers")
+    ```
+    """
+    errors = []
+
+    if not isinstance(handlers, list):
+        errors.append(f"GRPC_HANDLERS must be list, got {type(handlers)}")
+        return False, errors
+
+    for i, handler in enumerate(handlers):
+        if not validate_grpc_handler(handler):
+            errors.append(f"Handler #{i} is invalid")
+
+    all_valid = len(errors) == 0
+    return all_valid, errors
+
+
+# ============================================================================
+# Exports
+# ============================================================================
+
+__all__ = [
+    'create_grpc_handler',
+    'create_multiple_grpc_handlers',
+    'validate_grpc_handler',
+    'validate_grpc_handlers',
+]

django_cfg/apps/integrations/grpc/utils/proto_gen.py

@@ -394,7 +394,7 @@ def generate_proto_for_app(app_label: str, output_dir: Optional[Path] = None) ->
         ```
     """
     # Get gRPC config from django-cfg (Pydantic)
-    from ..services.config_helper import get_grpc_config
+    from ..services.management.config_helper import get_grpc_config
 
     grpc_config = get_grpc_config()
     proto_config = grpc_config.proto if grpc_config else None

django_cfg/apps/integrations/grpc/utils/streaming_logger.py

@@ -12,6 +12,45 @@ from pathlib import Path
 from typing import Optional
 from django.utils import timezone
 
+# Rich for beautiful console output
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+
+# ========================================================================
+# Module-level debug mode caching (performance optimization)
+# ========================================================================
+
+_debug_mode: Optional[bool] = None  # Cached debug mode to avoid repeated config loads
+
+
+def _get_debug_mode() -> bool:
+    """
+    Get debug mode from config (cached at module level).
+
+    Loads config only once and caches the result to avoid repeated config loads.
+    This is a performance optimization - config loading can be expensive.
+
+    Returns:
+        True if debug mode is enabled, False otherwise
+    """
+    global _debug_mode
+
+    if _debug_mode is not None:
+        return _debug_mode
+
+    # Load config once and cache
+    try:
+        from django_cfg.core.state import get_current_config
+        config = get_current_config()
+        _debug_mode = config.debug if config and hasattr(config, 'debug') else False
+    except Exception:
+        _debug_mode = os.getenv('DEBUG', 'false').lower() in ('true', '1', 'yes')
+
+    return _debug_mode
+
 
 class AutoTracebackHandler(logging.Handler):
     """
@@ -43,8 +82,8 @@ class AutoTracebackHandler(logging.Handler):
 def setup_streaming_logger(
     name: str = "grpc_streaming",
     logs_dir: Optional[Path] = None,
-    level: int = logging.DEBUG,
-    console_level: int = logging.INFO
+    level: Optional[int] = None,
+    console_level: Optional[int] = None
 ) -> logging.Logger:
     """
     Setup dedicated logger for gRPC streaming with file and console handlers.
@@ -52,14 +91,15 @@ def setup_streaming_logger(
     Follows django-cfg logging pattern:
     - Uses os.getcwd() / 'logs' / 'grpc_streaming' for log directory
     - Time-based log file names (streaming_YYYYMMDD_HHMMSS.log)
-    - Detailed file logging (DEBUG level by default)
-    - Concise console logging (INFO level by default)
+    - Auto-detects debug mode for appropriate logging levels
+    - In dev/debug: files=DEBUG+, console=DEBUG+
+    - In production: files=INFO+, console=WARNING+
 
     Args:
         name: Logger name (default: "grpc_streaming")
         logs_dir: Directory for log files (default: <cwd>/logs/grpc_streaming)
-        level: File logging level (default: DEBUG)
-        console_level: Console logging level (default: INFO)
+        level: File logging level (default: auto-detect from debug mode)
+        console_level: Console logging level (default: auto-detect from debug mode)
 
     Returns:
         Configured logger instance
@@ -68,14 +108,14 @@ def setup_streaming_logger(
         ```python
         from django_cfg.apps.integrations.grpc.utils import setup_streaming_logger
 
-        # Basic usage
+        # Basic usage (auto-detects debug mode)
         logger = setup_streaming_logger()
 
         # Custom configuration
         logger = setup_streaming_logger(
             name="my_streaming_service",
             logs_dir=Path("/var/log/grpc"),
-            level=logging.INFO
+            level=logging.INFO  # Override auto-detection
         )
 
         logger.info("Service started")
@@ -87,8 +127,21 @@ def setup_streaming_logger(
         - Time-based log file names
         - No duplicate logs (propagate=False)
         - UTF-8 encoding
+        - Debug mode auto-detection (cached for performance)
         - Reusable across all django-cfg gRPC projects
     """
+    # Auto-detect debug mode (cached - loaded once)
+    debug = _get_debug_mode()
+
+    # Auto-determine logging levels based on debug mode if not explicitly provided
+    if level is None:
+        # File handlers: DEBUG in dev, INFO in production
+        level = logging.DEBUG if debug else logging.INFO
+
+    if console_level is None:
+        # Console: DEBUG in dev (full visibility), WARNING in production (reduce noise)
+        console_level = logging.DEBUG if debug else logging.WARNING
+
     # Create logger
     streaming_logger = logging.getLogger(name)
     streaming_logger.setLevel(level)
@@ -128,11 +181,14 @@ def setup_streaming_logger(
     file_handler = AutoTracebackHandler(base_file_handler)
     streaming_logger.addHandler(file_handler)
 
-    # Console handler - important messages only
-    console_handler = logging.StreamHandler()
-    console_handler.setLevel(console_level)
+    # Console handler - important messages only (also with auto-traceback)
+    base_console_handler = logging.StreamHandler()
+    base_console_handler.setLevel(console_level)
     console_formatter = logging.Formatter('%(levelname)s: %(message)s')
-    console_handler.setFormatter(console_formatter)
+    base_console_handler.setFormatter(console_formatter)
+
+    # Wrap console handler with auto-traceback too
+    console_handler = AutoTracebackHandler(base_console_handler)
     streaming_logger.addHandler(console_handler)
 
     # Prevent propagation to avoid duplicate logs
@@ -174,4 +230,196 @@ def get_streaming_logger(name: str = "grpc_streaming") -> logging.Logger:
     return logger
 
 
-__all__ = ["setup_streaming_logger", "get_streaming_logger"]
+def log_server_start(
+    logger: logging.Logger,
+    server_type: str = "Server",
+    mode: str = "Development",
+    hotreload_enabled: bool = False,
+    use_rich: bool = True,
+    **extra_info
+):
+    """
+    Log server startup with timestamp and configuration using Rich panels.
+
+    Args:
+        logger: Logger instance to use
+        server_type: Type of server (e.g., "gRPC Server", "WebSocket Server")
+        mode: Running mode (Development/Production)
+        hotreload_enabled: Whether hot-reload is enabled
+        use_rich: Use Rich for beautiful output (default: True)
+        **extra_info: Additional key-value pairs to log
+
+    Example:
+        ```python
+        from django_cfg.apps.integrations.grpc.utils import log_server_start
+        from datetime import datetime
+
+        start_time = log_server_start(
+            logger,
+            server_type="gRPC Server",
+            mode="Development",
+            hotreload_enabled=True,
+            host="0.0.0.0",
+            port=50051
+        )
+        ```
+
+    Returns:
+        datetime object of start time for later use in log_server_shutdown
+    """
+    from datetime import datetime
+
+    start_time = datetime.now()
+
+    if use_rich:
+        # Create Rich table for server info
+        console = Console()
+
+        table = Table(show_header=False, box=None, padding=(0, 1))
+        table.add_column("Key", style="cyan")
+        table.add_column("Value", style="white")
+
+        table.add_row("⏰ Started at", start_time.strftime('%Y-%m-%d %H:%M:%S'))
+        table.add_row("Mode", f"[{'red' if mode == 'Production' else 'green'}]{mode}[/]")
+        table.add_row("Hotreload", f"[{'yellow' if hotreload_enabled else 'dim'}]{'Enabled ⚡' if hotreload_enabled else 'Disabled'}[/]")
+
+        # Add extra info
+        for key, value in extra_info.items():
+            key_display = key.replace('_', ' ').title()
+            table.add_row(key_display, str(value))
+
+        # Create panel
+        panel = Panel(
+            table,
+            title=f"[bold green]🚀 {server_type} Starting[/bold green]",
+            border_style="green",
+            padding=(1, 2)
+        )
+
+        console.print(panel)
+
+        if hotreload_enabled:
+            console.print(
+                "[yellow]⚠️  Hotreload active - connections may be dropped on code changes[/yellow]",
+                style="bold"
+            )
+    else:
+        # Fallback to simple logging
+        logger.info("=" * 80)
+        logger.info(f"🚀 {server_type} Starting")
+        logger.info(f"   ⏰ Started at: {start_time.strftime('%Y-%m-%d %H:%M:%S')}")
+        logger.info(f"   Mode: {mode}")
+        logger.info(f"   Hotreload: {'Enabled' if hotreload_enabled else 'Disabled'}")
+
+        for key, value in extra_info.items():
+            key_display = key.replace('_', ' ').title()
+            logger.info(f"   {key_display}: {value}")
+
+        if hotreload_enabled:
+            logger.warning(
+                "⚠️  Hotreload active - connections may be dropped on code changes"
+            )
+
+        logger.info("=" * 80)
+
+    return start_time
+
+
+def log_server_shutdown(
+    logger: logging.Logger,
+    start_time,
+    server_type: str = "Server",
+    reason: str = None,
+    use_rich: bool = True,
+    **extra_info
+):
+    """
+    Log server shutdown with uptime calculation using Rich panels.
+
+    Args:
+        logger: Logger instance to use
+        start_time: datetime object from log_server_start()
+        server_type: Type of server (e.g., "gRPC Server", "WebSocket Server")
+        reason: Shutdown reason (e.g., "Keyboard interrupt", "Hotreload")
+        use_rich: Use Rich for beautiful output (default: True)
+        **extra_info: Additional key-value pairs to log
+
+    Example:
+        ```python
+        from django_cfg.apps.integrations.grpc.utils import log_server_shutdown
+
+        log_server_shutdown(
+            logger,
+            start_time,
+            server_type="gRPC Server",
+            reason="Hotreload triggered",
+            active_connections=5
+        )
+        ```
+    """
+    from datetime import datetime
+
+    end_time = datetime.now()
+    uptime = end_time - start_time
+    uptime_seconds = int(uptime.total_seconds())
+
+    # Format uptime
+    hours = uptime_seconds // 3600
+    minutes = (uptime_seconds % 3600) // 60
+    seconds = uptime_seconds % 60
+    uptime_str = f"{hours}h {minutes}m {seconds}s"
+
+    if use_rich:
+        # Create Rich table for shutdown info
+        console = Console()
+
+        table = Table(show_header=False, box=None, padding=(0, 1))
+        table.add_column("Key", style="cyan")
+        table.add_column("Value", style="white")
+
+        if reason:
+            table.add_row("📋 Reason", reason)
+
+        table.add_row("⏱️  Uptime", f"[bold]{uptime_str}[/bold]")
+        table.add_row("🕐 Stopped at", end_time.strftime('%Y-%m-%d %H:%M:%S'))
+
+        # Add extra info
+        for key, value in extra_info.items():
+            key_display = key.replace('_', ' ').title()
+            table.add_row(key_display, str(value))
+
+        # Create panel
+        panel = Panel(
+            table,
+            title=f"[bold red]🧹 Shutting down {server_type}[/bold red]",
+            border_style="red",
+            padding=(1, 2)
+        )
+
+        console.print(panel)
+        console.print("[green]✅ Server shutdown complete[/green]", style="bold")
+    else:
+        # Fallback to simple logging
+        logger.info("=" * 80)
+        logger.info(f"🧹 Shutting down {server_type}...")
+
+        if reason:
+            logger.info(f"   📋 Reason: {reason}")
+
+        logger.info(f"   ⏱️  Uptime: {uptime_str}")
+        logger.info(f"   🕐 Stopped at: {end_time.strftime('%Y-%m-%d %H:%M:%S')}")
+
+        for key, value in extra_info.items():
+            key_display = key.replace('_', ' ').title()
+            logger.info(f"   {key_display}: {value}")
+
+        logger.info("✅ Server shutdown complete")
+        logger.info("=" * 80)
+
+
+__all__ = [
+    "setup_streaming_logger",
+    "get_streaming_logger",
+    "log_server_start",
+    "log_server_shutdown",
+]

django_cfg/apps/integrations/grpc/views/charts.py

@@ -22,7 +22,7 @@ from ..serializers.charts import (
     ServerUptimeChartSerializer,
     ServiceActivityChartSerializer,
 )
-from ..services.chart_generator import ChartGeneratorService
+from ..services.rendering.charts import ChartGeneratorService
 
 logger = get_logger("grpc.charts")
 

django_cfg/apps/integrations/grpc/views/config.py

@@ -16,7 +16,7 @@ from rest_framework.response import Response
 from ..models import GRPCRequestLog, GRPCServerStatus
 from ..serializers.config import GRPCConfigSerializer, GRPCServerInfoSerializer
 from ..services import ServiceDiscovery
-from ..services.config_helper import get_grpc_config, get_grpc_server_config
+from ..services.management.config_helper import get_grpc_config, get_grpc_server_config
 
 logger = get_logger("grpc.config")