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

django_cfg/middleware/pool_cleanup.py

@@ -0,0 +1,261 @@
+"""
+Connection Pool Cleanup Middleware.
+
+Ensures database connections are properly returned to the pool after each
+request, including error cases. Prevents connection leaks in production.
+
+Usage:
+    Add to MIDDLEWARE in settings.py:
+    MIDDLEWARE = [
+        # ... other middleware ...
+        'django_cfg.middleware.pool_cleanup.ConnectionPoolCleanupMiddleware',
+    ]
+
+Note:
+    This middleware should be placed AFTER all other middleware to ensure
+    cleanup happens regardless of what other middleware does.
+"""
+
+import logging
+import time
+from typing import Callable
+
+from django.db import connection, connections, transaction
+from django.http import HttpRequest, HttpResponse
+from django.utils.deprecation import MiddlewareMixin
+
+logger = logging.getLogger('django_cfg.middleware.pool_cleanup')
+
+
+class ConnectionPoolCleanupMiddleware(MiddlewareMixin):
+    """
+    Middleware to ensure database connections are cleaned up after each request.
+
+    Features:
+    - Closes connections after successful responses
+    - Closes connections after exceptions
+    - Rolls back uncommitted transactions on errors
+    - Works with both sync and async views
+    - Minimal performance overhead (<1ms)
+
+    This middleware is critical when using connection pooling with
+    ATOMIC_REQUESTS=False, as it ensures connections don't leak.
+    """
+
+    def __init__(self, get_response: Callable):
+        """
+        Initialize middleware.
+
+        Args:
+            get_response: The next middleware or view to call
+        """
+        super().__init__(get_response)
+        self.get_response = get_response
+        self._enable_logging = False  # Set to True for debug logging
+
+    def __call__(self, request: HttpRequest) -> HttpResponse:
+        """
+        Process request through middleware chain.
+
+        Args:
+            request: The HTTP request
+
+        Returns:
+            HttpResponse from view or next middleware
+        """
+        start_time = time.time() if self._enable_logging else None
+
+        try:
+            response = self.get_response(request)
+            return response
+        finally:
+            # Cleanup happens in finally block to ensure it runs
+            self._cleanup_connections(request, rollback_on_error=False)
+
+            if self._enable_logging and start_time:
+                duration_ms = (time.time() - start_time) * 1000
+                logger.debug(f"Pool cleanup overhead: {duration_ms:.2f}ms")
+
+    def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse:
+        """
+        Process response before returning to client.
+
+        Called after view execution for successful responses.
+
+        Args:
+            request: The HTTP request
+            response: The HTTP response from view
+
+        Returns:
+            The HTTP response (unchanged)
+        """
+        # Cleanup handled in __call__ finally block
+        return response
+
+    def process_exception(self, request: HttpRequest, exception: Exception) -> None:
+        """
+        Process exception raised during request handling.
+
+        Called when view raises an exception. Rolls back any pending
+        transactions and closes connections.
+
+        Args:
+            request: The HTTP request
+            exception: The exception that was raised
+
+        Returns:
+            None (allows exception to propagate)
+        """
+        logger.warning(
+            f"Exception in request, rolling back transactions: {exception.__class__.__name__}",
+            extra={
+                'path': request.path,
+                'method': request.method,
+                'exception': str(exception),
+            }
+        )
+
+        # Rollback all open transactions
+        self._cleanup_connections(request, rollback_on_error=True)
+
+        # Return None to allow exception to propagate
+        return None
+
+    def _cleanup_connections(self, request: HttpRequest, rollback_on_error: bool = False) -> None:
+        """
+        Clean up all database connections.
+
+        Args:
+            request: The HTTP request
+            rollback_on_error: If True, rollback uncommitted transactions
+        """
+        for db_alias in connections:
+            try:
+                conn = connections[db_alias]
+
+                # Check if connection is open
+                if conn.connection is None:
+                    continue
+
+                # Rollback uncommitted transactions if requested
+                if rollback_on_error:
+                    self._rollback_transaction(conn, db_alias)
+
+                # Close the connection to return it to pool
+                # Django's close() is safe to call multiple times
+                conn.close()
+
+            except Exception as e:
+                logger.error(
+                    f"Error cleaning up connection '{db_alias}': {e}",
+                    exc_info=True,
+                    extra={
+                        'database': db_alias,
+                        'path': request.path,
+                    }
+                )
+
+    def _rollback_transaction(self, conn, db_alias: str) -> None:
+        """
+        Rollback any uncommitted transaction on a connection.
+
+        Args:
+            conn: Database connection
+            db_alias: Database alias for logging
+        """
+        try:
+            # Check if there's an open transaction
+            if conn.in_atomic_block:
+                logger.debug(f"Rolling back transaction for database '{db_alias}'")
+                conn.rollback()
+        except Exception as e:
+            logger.error(
+                f"Error rolling back transaction for '{db_alias}': {e}",
+                exc_info=True
+            )
+
+
+class AsyncConnectionPoolCleanupMiddleware:
+    """
+    Async version of ConnectionPoolCleanupMiddleware.
+
+    Use this middleware in ASGI deployments for better async compatibility.
+
+    Usage:
+        MIDDLEWARE = [
+            'django_cfg.middleware.pool_cleanup.AsyncConnectionPoolCleanupMiddleware',
+        ]
+    """
+
+    def __init__(self, get_response: Callable):
+        """
+        Initialize async middleware.
+
+        Args:
+            get_response: The next middleware or view to call
+        """
+        self.get_response = get_response
+        self._enable_logging = False
+
+    async def __call__(self, request: HttpRequest) -> HttpResponse:
+        """
+        Process request through middleware chain (async).
+
+        Args:
+            request: The HTTP request
+
+        Returns:
+            HttpResponse from view or next middleware
+        """
+        start_time = time.time() if self._enable_logging else None
+
+        try:
+            response = await self.get_response(request)
+            return response
+        except Exception as e:
+            # Rollback on exception
+            logger.warning(
+                f"Exception in async request, rolling back: {e.__class__.__name__}",
+                extra={'path': request.path, 'exception': str(e)}
+            )
+            self._cleanup_connections(request, rollback_on_error=True)
+            raise
+        finally:
+            # Always cleanup connections
+            self._cleanup_connections(request, rollback_on_error=False)
+
+            if self._enable_logging and start_time:
+                duration_ms = (time.time() - start_time) * 1000
+                logger.debug(f"Async pool cleanup overhead: {duration_ms:.2f}ms")
+
+    def _cleanup_connections(self, request: HttpRequest, rollback_on_error: bool = False) -> None:
+        """
+        Clean up all database connections (sync code in async middleware).
+
+        Args:
+            request: The HTTP request
+            rollback_on_error: If True, rollback uncommitted transactions
+        """
+        for db_alias in connections:
+            try:
+                conn = connections[db_alias]
+
+                if conn.connection is None:
+                    continue
+
+                if rollback_on_error and conn.in_atomic_block:
+                    logger.debug(f"Rolling back async transaction for '{db_alias}'")
+                    conn.rollback()
+
+                conn.close()
+
+            except Exception as e:
+                logger.error(
+                    f"Error cleaning up async connection '{db_alias}': {e}",
+                    exc_info=True,
+                    extra={'database': db_alias, 'path': request.path}
+                )
+
+
+# Default export - use sync middleware
+__all__ = ['ConnectionPoolCleanupMiddleware', 'AsyncConnectionPoolCleanupMiddleware']

django_cfg/models/api/grpc/config.py

@@ -370,9 +370,9 @@ class GRPCConfig(BaseConfig):
         description="Proto generation configuration (optional, use flatten fields above for common settings)",
     )
 
-    handlers_hook: str = Field(
+    handlers_hook: str | List[str] = Field(
         default="",
-        description="Import path to grpc_handlers function (optional, e.g., '{ROOT_URLCONF}.grpc_handlers')",
+        description="Import path(s) to grpc_handlers function (optional, e.g., '{ROOT_URLCONF}.grpc_handlers' or list of paths)",
     )
 
     auto_register_apps: bool = Field(

django_cfg/models/infrastructure/database/config.py

@@ -81,6 +81,18 @@ class DatabaseConfig(BaseModel):
         description="Additional database-specific options",
     )
 
+    # Connection pooling options (CRITICAL for preventing connection exhaustion)
+    conn_max_age: int = Field(
+        default=0,  # 0 disables persistent connections when using connection pooling
+        description="Maximum age of database connections in seconds. Must be 0 when using connection pooling.",
+        ge=0,
+    )
+
+    conn_health_checks: bool = Field(
+        default=True,
+        description="Enable database connection health checks",
+    )
+
     # Database routing configuration
     apps: List[str] = Field(
         default_factory=list,
@@ -223,6 +235,8 @@ class DatabaseConfig(BaseModel):
         apps: Optional[List[str]] = None,
         operations: Optional[List[Literal["read", "write", "migrate"]]] = None,
         routing_description: str = "",
+        conn_max_age: int = 0,  # 0 disables persistent connections when using connection pooling
+        conn_health_checks: bool = True,
         **kwargs
     ) -> "DatabaseConfig":
         """
@@ -254,6 +268,8 @@ class DatabaseConfig(BaseModel):
             apps=apps or [],
             operations=operations or ["read", "write", "migrate"],
             routing_description=routing_description,
+            conn_max_age=conn_max_age,
+            conn_health_checks=conn_health_checks,
             **kwargs
         )
 

django_cfg/models/infrastructure/database/converters.py

@@ -25,6 +25,8 @@ def to_django_config(config: "DatabaseConfig") -> Dict[str, Any]:  # type: ignor
         django_config = {
             "ENGINE": config.engine,
             "OPTIONS": {**config.options},
+            "CONN_MAX_AGE": config.conn_max_age,
+            "CONN_HEALTH_CHECKS": config.conn_health_checks,
         }
 
         # Add database-specific options

django_cfg/modules/django_admin/utils/html/composition.py

@@ -28,7 +28,8 @@ class CompositionElements:
 
     @staticmethod
     def icon_text(icon_or_text: Union[str, Any], text: Any = None,
-                  icon_size: str = "xs", separator: str = " ") -> SafeString:
+                  icon_size: str = "xs", separator: str = " ", 
+                  color: str = None) -> SafeString:
         """
         Render icon with text or emoji with text.
 
@@ -37,28 +38,35 @@ class CompositionElements:
             text: Optional text to display after icon
             icon_size: Icon size (xs, sm, base, lg, xl)
             separator: Separator between icon and text
+            color: Optional color (success, warning, danger, info, secondary, primary)
 
         Usage:
             html.icon_text(Icons.EDIT, 5)  # Icon with number
-            html.icon_text("📝", 5)  # Emoji with number
             html.icon_text("Active")  # Just text
+            html.icon_text(Icons.CHECK, "Yes", color="success")  # Icon with color
         """
+        # Color mapping to Tailwind/Unfold classes
+        color_classes = {
+            'success': 'text-green-600 dark:text-green-400',
+            'warning': 'text-yellow-600 dark:text-yellow-400',
+            'danger': 'text-red-600 dark:text-red-400',
+            'error': 'text-red-600 dark:text-red-400',
+            'info': 'text-blue-600 dark:text-blue-400',
+            'secondary': 'text-gray-600 dark:text-gray-400',
+            'primary': 'text-indigo-600 dark:text-indigo-400',
+        }
+        
+        color_class = color_classes.get(color, '') if color else ''
+        
         if text is None:
             # Just text
+            if color_class:
+                return format_html('<span class="{}">{}</span>', color_class, escape(str(icon_or_text)))
             return format_html('<span>{}</span>', escape(str(icon_or_text)))
 
-        # Check if it's a Material Icon (from Icons class) or emoji
+        # Render icon (Material Icon from Icons class)
         icon_str = str(icon_or_text)
-
-        # Detect if it's emoji by checking for non-ASCII characters
-        is_emoji = any(ord(c) > 127 for c in icon_str)
-
-        if is_emoji or icon_str in ['📝', '💬', '🛒', '👤', '📧', '🔔', '⚙️', '🔧', '📊', '🎯']:
-            # Emoji
-            icon_html = escape(icon_str)
-        else:
-            # Material Icon
-            icon_html = CompositionElements.icon(icon_str, size=icon_size)
+        icon_html = CompositionElements.icon(icon_str, size=icon_size)
 
         # DON'T escape SafeString - it's already safe HTML!
         from django.utils.safestring import SafeString
@@ -67,8 +75,44 @@ class CompositionElements:
         else:
             text_html = escape(str(text))
 
+        # Wrap in span with color class if provided
+        if color_class:
+            return format_html('<span class="{}">{}{}<span>{}</span></span>', 
+                             color_class, icon_html, separator, text_html)
+
         return format_html('{}{}<span>{}</span>', icon_html, separator, text_html)
 
+    @staticmethod
+    def colored_text(text: Any, color: str = None) -> SafeString:
+        """
+        Render colored text.
+
+        Args:
+            text: Text to display
+            color: Color (success, warning, danger, info, secondary, primary)
+
+        Usage:
+            html.colored_text("Active", "success")
+            html.colored_text("5 minutes ago", "warning")
+        """
+        # Color mapping to Tailwind/Unfold classes
+        color_classes = {
+            'success': 'text-green-600 dark:text-green-400',
+            'warning': 'text-yellow-600 dark:text-yellow-400',
+            'danger': 'text-red-600 dark:text-red-400',
+            'error': 'text-red-600 dark:text-red-400',
+            'info': 'text-blue-600 dark:text-blue-400',
+            'secondary': 'text-gray-600 dark:text-gray-400',
+            'primary': 'text-indigo-600 dark:text-indigo-400',
+        }
+        
+        color_class = color_classes.get(color, '') if color else ''
+        
+        if color_class:
+            return format_html('<span class="{}">{}</span>', color_class, escape(str(text)))
+        
+        return format_html('<span>{}</span>', escape(str(text)))
+
     @staticmethod
     def inline(*items, separator: str = " | ",
                size: str = "small", css_class: str = "") -> SafeString:

django_cfg/modules/django_admin/utils/html_builder.py

@@ -45,6 +45,7 @@ class HtmlBuilder:
     # === CompositionElements ===
     inline = staticmethod(CompositionElements.inline)
     icon_text = staticmethod(CompositionElements.icon_text)
+    colored_text = staticmethod(CompositionElements.colored_text)
     header = staticmethod(CompositionElements.header)
 
     # === FormattingElements ===

django_cfg/modules/django_client/core/groups/manager.py

@@ -230,25 +230,32 @@ from django_cfg.apps.urls import urlpatterns
             for app_name in apps:
                 # Try to include app URLs
                 try:
-                    # Find app config by full name
-                    app_config = None
-                    for config in django_apps.get_app_configs():
-                        if config.name == app_name:
-                            app_config = config
-                            break
-
-                    if app_config:
-                        # Use actual label from AppConfig
-                        app_label = app_config.label
-                        # Add API prefix from config (e.g., "api/workspaces/" instead of just "workspaces/")
-                        api_prefix = getattr(self.config, 'api_prefix', '').strip('/')
-                        if api_prefix:
-                            url_path = f"{api_prefix}/{app_label}/"
-                        else:
-                            url_path = f"{app_label}/"
-                        urlpatterns.append(f'    path("{url_path}", include("{app_name}.urls")),')
+                    # Check if app has urls.py module
+                    import importlib
+                    urls_module = f"{app_name}.urls"
+                    try:
+                        importlib.import_module(urls_module)
+                        has_urls = True
+                    except ImportError:
+                        has_urls = False
+                    
+                    if not has_urls:
+                        logger.debug(f"App '{app_name}' has no urls.py - skipping")
+                        continue
+                    
+                    # Determine URL path based on whether app has urls.py
+                    # If app has urls.py, use basename (matches url_integration.py logic)
+                    # e.g., "apps.web.controls" -> "controls"
+                    app_basename = app_name.split('.')[-1]
+                    
+                    # Add API prefix from config (e.g., "api/controls/" instead of just "controls/")
+                    api_prefix = getattr(self.config, 'api_prefix', '').strip('/')
+                    if api_prefix:
+                        url_path = f"{api_prefix}/{app_basename}/"
                     else:
-                        logger.debug(f"App '{app_name}' not found in installed apps")
+                        url_path = f"{app_basename}/"
+                    
+                    urlpatterns.append(f'    path("{url_path}", include("{app_name}.urls")),')
                 except Exception as e:
                     logger.debug(f"App '{app_name}' skipped: {e}")
                     continue

django_cfg/modules/django_client/management/commands/generate_client.py

@@ -586,6 +586,14 @@ class Command(AdminCommand):
 
             self.stdout.write(f"\n📦 Copying TypeScript clients to Next.js admin...")
 
+            # Clean api_output_path before copying (remove old generated files)
+            if api_output_path.exists():
+                self.stdout.write(f"  🧹 Cleaning API output directory: {api_output_path.relative_to(project_path)}")
+                shutil.rmtree(api_output_path)
+
+            # Recreate directory
+            api_output_path.mkdir(parents=True, exist_ok=True)
+
             # Copy each group (exclude 'cfg' for Next.js admin)
             copied_count = 0
             for group_dir in ts_source.iterdir():
@@ -601,11 +609,7 @@ class Command(AdminCommand):
 
                 target_dir = api_output_path / group_name
 
-                # Remove old
-                if target_dir.exists():
-                    shutil.rmtree(target_dir)
-
-                # Copy new
+                # Copy group directory
                 shutil.copytree(group_dir, target_dir)
                 copied_count += 1
 

django_cfg/modules/django_logging/django_logger.py

@@ -65,6 +65,32 @@ class DjangoLogger(BaseCfgModule):
 
     _loggers: Dict[str, logging.Logger] = {}
     _configured = False
+    _debug_mode: Optional[bool] = None  # Cached debug mode to avoid repeated config loads
+
+    @classmethod
+    def _get_debug_mode(cls) -> bool:
+        """
+        Get debug mode from config (cached).
+
+        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
+        """
+        if cls._debug_mode is not None:
+            return cls._debug_mode
+
+        # Load config once and cache
+        try:
+            from django_cfg.core.state import get_current_config
+            config = get_current_config()
+            cls._debug_mode = config.debug if config and hasattr(config, 'debug') else False
+        except Exception:
+            import os
+            cls._debug_mode = os.getenv('DEBUG', 'false').lower() in ('true', '1', 'yes')
+
+        return cls._debug_mode
 
     @classmethod
     def get_logger(cls, name: str = "django_cfg") -> logging.Logger:
@@ -92,13 +118,8 @@ class DjangoLogger(BaseCfgModule):
         # print(f"  Django logs: {logs_dir / 'django.log'}")
         # print(f"  Django-CFG logs: {djangocfg_logs_dir}/")
 
-        # Get debug mode
-        try:
-            from django_cfg.core.state import get_current_config
-            config = get_current_config()
-            debug = config.debug if config else False
-        except Exception:
-            debug = os.getenv('DEBUG', 'false').lower() in ('true', '1', 'yes')
+        # Get debug mode (cached - loaded once)
+        debug = cls._get_debug_mode()
 
         # Create handlers
         try:
@@ -111,9 +132,13 @@ class DjangoLogger(BaseCfgModule):
                 backupCount=30,  # Keep 30 days of logs
                 encoding='utf-8',
             )
-            django_handler.setLevel(logging.DEBUG if debug else logging.INFO)  # INFO+ in production, DEBUG in dev
+            # File handlers ALWAYS capture DEBUG in dev mode (for complete debugging history)
+            # In production, still use INFO+ to save disk space
+            django_handler.setLevel(logging.DEBUG if debug else logging.INFO)
 
-            # Console handler - WARNING+ always (less noise)
+            # Console handler - configurable noise level
+            # In dev: show DEBUG+ (full visibility)
+            # In production: show WARNING+ only (reduce noise)
             console_handler = logging.StreamHandler()
             console_handler.setLevel(logging.DEBUG if debug else logging.WARNING)
 
@@ -123,8 +148,10 @@ class DjangoLogger(BaseCfgModule):
             console_handler.setFormatter(formatter)
 
             # Configure root logger
+            # CRITICAL: Root logger must be DEBUG in dev mode to allow all messages through
+            # Handlers will filter based on their own levels, but logger must not block
             root_logger = logging.getLogger()
-            root_logger.setLevel(logging.DEBUG if debug else logging.INFO)  # INFO+ in production, DEBUG in dev
+            root_logger.setLevel(logging.DEBUG if debug else logging.INFO)
 
             # Clear existing handlers
             root_logger.handlers.clear()
@@ -149,9 +176,24 @@ class DjangoLogger(BaseCfgModule):
 
     @classmethod
     def _create_logger(cls, name: str) -> logging.Logger:
-        """Create logger with modular file handling for django-cfg loggers."""
+        """
+        Create logger with modular file handling for django-cfg loggers.
+
+        In dev/debug mode, loggers inherit DEBUG level from root logger,
+        ensuring all log messages reach file handlers regardless of explicit level settings.
+        """
         logger = logging.getLogger(name)
 
+        # In dev mode, ensure logger doesn't block DEBUG messages
+        # Logger inherits from root by default (propagate=True), which is set to DEBUG in dev
+        # This is crucial: logger level must be <= handler level, or messages get blocked
+        debug = cls._get_debug_mode()  # Use cached debug mode
+
+        # In dev mode, force DEBUG level on logger to ensure complete file logging
+        # Handlers will still filter console output (WARNING+), but files get everything (DEBUG+)
+        if debug and not logger.level:
+            logger.setLevel(logging.DEBUG)
+
         # If this is a django-cfg logger, add a specific file handler
         if name.startswith('django_cfg'):
             try:
@@ -181,15 +223,12 @@ class DjangoLogger(BaseCfgModule):
                     encoding='utf-8',
                 )
 
-                # Get debug mode
-                try:
-                    from django_cfg.core.state import get_current_config
-                    config = get_current_config()
-                    debug = config.debug if config else False
-                except Exception:
-                    debug = os.getenv('DEBUG', 'false').lower() in ('true', '1', 'yes')
+                # Get debug mode (cached - loaded once)
+                debug = cls._get_debug_mode()
 
-                file_handler.setLevel(logging.DEBUG if debug else logging.INFO)  # INFO+ in production, DEBUG in dev
+                # Module file handlers ALWAYS capture DEBUG in dev mode
+                # This ensures complete log history for debugging, independent of logger level
+                file_handler.setLevel(logging.DEBUG if debug else logging.INFO)
 
                 # Set format
                 formatter = logging.Formatter('[%(asctime)s] %(levelname)s in %(name)s [%(filename)s:%(lineno)d]: %(message)s')

django_cfg/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-cfg"
-version = "1.5.20"
+version = "1.5.29"
 description = "Modern Django framework with type-safe Pydantic v2 configuration, Next.js admin integration, real-time WebSockets, and 8 enterprise apps. Replace settings.py with validated models, 90% less code. Production-ready with AI agents, auto-generated TypeScript clients, and zero-config features."
 readme = "README.md"
 keywords = [ "django", "configuration", "pydantic", "settings", "type-safety", "pydantic-settings", "django-environ", "startup-validation", "ide-autocomplete", "nextjs-admin", "react-admin", "websocket", "centrifugo", "real-time", "typescript-generation", "ai-agents", "enterprise-django", "django-settings", "type-safe-config", "modern-django",]
@@ -26,13 +26,13 @@ text = "MIT"
 local = []
 django52 = [ "django>=5.2,<6.0",]
 ai = [ "pydantic-ai>=1.0.10,<2.0",]
-grpc = [ "grpcio>=1.50.0,<2.0", "grpcio-tools>=1.50.0,<2.0", "grpcio-reflection>=1.50.0,<2.0", "grpcio-health-checking>=1.50.0,<2.0", "protobuf>=5.0,<7.0",]
+grpc = [ "grpcio>=1.50.0,<2.0", "grpcio-tools>=1.50.0,<2.0", "grpcio-reflection>=1.50.0,<2.0", "grpcio-health-checking>=1.50.0,<2.0", "protobuf>=5.0,<7.0", "aiobreaker>=1.2.0,<2.0",]
 centrifugo = [ "cent>=5.0.0,<6.0", "websockets>=13.0,<15.0",]
 dev = [ "django>=5.2,<6.0", "pytest>=7.0", "pytest-django>=4.5", "pytest-cov>=4.0", "pytest-mock>=3.0", "factory-boy>=3.0", "fakeredis>=2.0", "black>=23.0", "isort>=5.0", "flake8>=5.0", "mypy>=1.0", "pre-commit>=3.0", "build>=1.0", "twine>=4.0", "tomlkit>=0.11", "questionary>=2.0", "rich>=13.0", "mkdocs>=1.5", "mkdocs-material>=9.0", "mkdocstrings[python]>=0.24", "redis>=5.0",]
 test = [ "django>=5.2,<6.0", "pytest>=7.0", "pytest-django>=4.5", "pytest-cov>=4.0", "pytest-mock>=3.0", "pytest-xdist>=3.0", "factory-boy>=3.0", "fakeredis>=2.0",]
 docs = [ "mkdocs>=1.5", "mkdocs-material>=9.0", "mkdocstrings[python]>=0.24", "pymdown-extensions>=10.0",]
 tasks = [ "redis>=5.0",]
-full = [ "django>=5.2,<6.0", "pytest>=7.0", "pytest-django>=4.5", "pytest-cov>=4.0", "pytest-mock>=3.0", "pytest-xdist>=3.0", "factory-boy>=3.0", "black>=23.0", "isort>=5.0", "flake8>=5.0", "mypy>=1.0", "pre-commit>=3.0", "build>=1.0", "twine>=4.0", "tomlkit>=0.11", "questionary>=2.0", "rich>=13.0", "mkdocs>=1.5", "mkdocs-material>=9.0", "mkdocstrings[python]>=0.24", "pymdown-extensions>=10.0", "redis>=5.0", "grpcio>=1.50.0,<2.0", "grpcio-tools>=1.50.0,<2.0", "grpcio-reflection>=1.50.0,<2.0", "grpcio-health-checking>=1.50.0,<2.0", "protobuf>=5.0,<7.0", "cent>=5.0.0,<6.0", "websockets>=13.0,<15.0", "django-rq>=3.0", "rq>=1.0", "rq-scheduler>=0.13", "hiredis>=2.0",]
+full = [ "django>=5.2,<6.0", "pytest>=7.0", "pytest-django>=4.5", "pytest-cov>=4.0", "pytest-mock>=3.0", "pytest-xdist>=3.0", "factory-boy>=3.0", "black>=23.0", "isort>=5.0", "flake8>=5.0", "mypy>=1.0", "pre-commit>=3.0", "build>=1.0", "twine>=4.0", "tomlkit>=0.11", "questionary>=2.0", "rich>=13.0", "mkdocs>=1.5", "mkdocs-material>=9.0", "mkdocstrings[python]>=0.24", "pymdown-extensions>=10.0", "redis>=5.0", "grpcio>=1.50.0,<2.0", "grpcio-tools>=1.50.0,<2.0", "grpcio-reflection>=1.50.0,<2.0", "grpcio-health-checking>=1.50.0,<2.0", "protobuf>=5.0,<7.0", "aiobreaker>=1.2.0,<2.0", "cent>=5.0.0,<6.0", "websockets>=13.0,<15.0", "django-rq>=3.0", "rq>=1.0", "rq-scheduler>=0.13", "hiredis>=2.0",]
 rq = [ "django-rq>=3.0", "rq>=1.0", "rq-scheduler>=0.13", "redis>=5.0", "hiredis>=2.0",]
 
 [project.urls]