django-cfg 1.2.29__py3-none-any.whl → 1.3.1__py3-none-any.whl

django_cfg/modules/django_logger.py

@@ -1,195 +1,209 @@
 """
-Auto-configuring Django Logger for django_cfg.
+Simple auto-configuring Django Logger for django_cfg.
 
-This logger automatically configures itself based on the DjangoConfig instance
-without requiring manual parameter passing.
+KISS principle: simple, unified logging configuration.
 """
 
 import logging
-from typing import Optional, Dict, Any, Union
 from pathlib import Path
+from typing import Dict, Optional
 
 from . import BaseCfgModule
+from ..utils.smart_defaults import get_log_filename
 
 
 class DjangoLogger(BaseCfgModule):
-    """
-    Auto-configuring logger that gets settings from DjangoConfig.
-    
-    Usage:
-        from django_cfg.modules import DjangoLogger
-        
-        logger = DjangoLogger.get_logger("myapp")
-        logger.info("This works automatically!")
-    """
+    """Simple auto-configuring logger."""
     
     _loggers: Dict[str, logging.Logger] = {}
+    _configured = False
     
     @classmethod
     def get_logger(cls, name: str = "django_cfg") -> logging.Logger:
-        """
-        Get a configured logger instance.
+        """Get a configured logger instance."""
+        if not cls._configured:
+            cls._setup_logging()
         
-        Args:
-            name: Logger name (default: "django_cfg")
-            
-        Returns:
-            Configured logger instance
-        """
         if name not in cls._loggers:
             cls._loggers[name] = cls._create_logger(name)
         return cls._loggers[name]
     
     @classmethod
-    def _create_logger(cls, name: str) -> logging.Logger:
-        """Create and configure a logger based on DjangoConfig."""
+    def _setup_logging(cls):
+        """Setup modular logging configuration with separate files per module."""
+        import os
+        current_dir = Path(os.getcwd())
+        logs_dir = current_dir / 'logs'
+        djangocfg_logs_dir = logs_dir / 'djangocfg'
+        
+        # Create directories
+        logs_dir.mkdir(parents=True, exist_ok=True)
+        djangocfg_logs_dir.mkdir(parents=True, exist_ok=True)
+        
+        print(f"[django-cfg] Setting up modular logging:")
+        print(f"  Django logs: {logs_dir / 'django.log'}")
+        print(f"  Django-CFG logs: {djangocfg_logs_dir}/")
+        
+        # Get debug mode
         try:
             from django_cfg.core.config import get_current_config
             config = get_current_config()
+            debug = config.debug if config else False
         except Exception:
-            config = None
-        
-        # Create logger
-        logger = logging.getLogger(name)
-        
-        # Get logging configuration from config
-        log_level = logging.INFO
-        console_output = True
-        file_path = None
-        
-        # Try to get logging config from DjangoConfig
-        if hasattr(config, 'logging') and config.logging:
-            logging_config = config.logging
-            log_level = getattr(logging, logging_config.level.upper(), logging.INFO)
-            console_output = logging_config.console_output
-            file_path = logging_config.file_path
+            debug = os.getenv('DEBUG', 'false').lower() in ('true', '1', 'yes')
         
-        # Set logger level
-        logger.setLevel(log_level)
-        
-        # Clear existing handlers
-        logger.handlers.clear()
-        
-        # Add console handler if enabled
-        if console_output:
+        # Create handlers
+        try:
+            # Handler for general Django logs
+            django_log_path = logs_dir / 'django.log'
+            django_handler = logging.FileHandler(django_log_path, encoding='utf-8')
+            django_handler.setLevel(logging.DEBUG if debug else logging.INFO)
+            
+            # Console handler
             console_handler = logging.StreamHandler()
-            console_handler.setLevel(log_level)
+            console_handler.setLevel(logging.DEBUG if debug else logging.INFO)
             
-            # Create formatter
-            formatter = cls._create_formatter(config)
+            # Set format for handlers
+            formatter = logging.Formatter('[%(asctime)s] %(levelname)s in %(name)s [%(filename)s:%(lineno)d]: %(message)s')
+            django_handler.setFormatter(formatter)
             console_handler.setFormatter(formatter)
             
-            logger.addHandler(console_handler)
-        
-        # Add file handler if file path is specified
-        if file_path:
-            file_path_obj = Path(file_path)
-            file_path_obj.parent.mkdir(parents=True, exist_ok=True)
+            # Configure root logger
+            root_logger = logging.getLogger()
+            root_logger.setLevel(logging.DEBUG if debug else logging.INFO)
             
-            file_handler = logging.FileHandler(file_path_obj)
-            file_handler.setLevel(log_level)
+            # Clear existing handlers
+            root_logger.handlers.clear()
             
-            # Create formatter for file
-            file_formatter = cls._create_file_formatter(config)
-            file_handler.setFormatter(file_formatter)
+            # Add handlers to root logger
+            root_logger.addHandler(console_handler)
+            root_logger.addHandler(django_handler)  # All logs go to django.log
             
-            logger.addHandler(file_handler)
-        
-        return logger
-    
-    @classmethod
-    def _create_formatter(cls, config) -> logging.Formatter:
-        """Create console formatter based on config."""
-        if config.debug:
-            # Detailed format for development
-            format_str = '[%(asctime)s] %(levelname)s in %(name)s: %(message)s'
-        else:
-            # Simple format for production
-            format_str = '%(levelname)s: %(message)s'
-        
-        return logging.Formatter(format_str)
-    
-    @classmethod
-    def _create_file_formatter(cls, config) -> logging.Formatter:
-        """Create file formatter based on config."""
-        # Always detailed format for file logging
-        format_str = '[%(asctime)s] %(levelname)s in %(name)s [%(filename)s:%(lineno)d]: %(message)s'
-        return logging.Formatter(format_str)
+            print(f"[django-cfg] Modular logging configured successfully! Debug: {debug}")
+            cls._configured = True
+            
+        except Exception as e:
+            print(f"[django-cfg] ERROR setting up modular logging: {e}")
+            # Fallback to console only
+            logging.basicConfig(
+                level=logging.DEBUG if debug else logging.INFO,
+                format='[%(asctime)s] %(levelname)s in %(name)s [%(filename)s:%(lineno)d]: %(message)s',
+                handlers=[logging.StreamHandler()],
+                force=True
+            )
+            cls._configured = True
     
     @classmethod
-    def configure_django_logging(cls) -> Dict[str, Any]:
-        """
-        Generate Django LOGGING configuration automatically.
-        
-        Returns:
-            Django LOGGING configuration dict
-        """
-        try:
-            from django_cfg.core.config import get_current_config
-            config = get_current_config()
-        except Exception:
-            config = None
+    def _create_logger(cls, name: str) -> logging.Logger:
+        """Create logger with modular file handling for django-cfg loggers."""
+        logger = logging.getLogger(name)
         
-        logging_config = {
-            'version': 1,
-            'disable_existing_loggers': False,
-            'formatters': {
-                'verbose': {
-                    'format': '[{asctime}] {levelname} in {name}: {message}',
-                    'style': '{',
-                },
-                'simple': {
-                    'format': '{levelname}: {message}',
-                    'style': '{',
-                },
-            },
-            'handlers': {
-                'console': {
-                    'class': 'logging.StreamHandler',
-                    'formatter': 'verbose' if config.debug else 'simple',
-                },
-            },
-            'root': {
-                'handlers': ['console'],
-                'level': 'DEBUG' if config.debug else 'INFO',
-            },
-            'loggers': {
-                'django_cfg': {
-                    'handlers': ['console'],
-                    'level': 'DEBUG' if config.debug else 'INFO',
-                    'propagate': False,
-                },
-            },
-        }
+        # If this is a django-cfg logger, add a specific file handler
+        if name.startswith('django_cfg'):
+            try:
+                import os
+                current_dir = Path(os.getcwd())
+                djangocfg_logs_dir = current_dir / 'logs' / 'djangocfg'
+                djangocfg_logs_dir.mkdir(parents=True, exist_ok=True)
+                
+                # Extract module name from logger name
+                # e.g., 'django_cfg.payments.provider' -> 'payments'
+                # e.g., 'django_cfg.core' -> 'core'
+                # e.g., 'django_cfg' -> 'core'
+                parts = name.split('.')
+                if len(parts) > 1:
+                    module_name = parts[1]  # django_cfg.payments -> payments
+                else:
+                    module_name = 'core'  # django_cfg -> core
+                
+                log_file_path = djangocfg_logs_dir / f'{module_name}.log'
+                
+                # Create file handler for this specific module
+                file_handler = logging.FileHandler(log_file_path, encoding='utf-8')
+                
+                # Get debug mode
+                try:
+                    from django_cfg.core.config 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')
+                
+                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')
+                file_handler.setFormatter(formatter)
+                
+                # Add handler to logger
+                logger.addHandler(file_handler)
+                logger.propagate = True  # Also send to parent (django.log)
+                
+                print(f"[django-cfg] Created modular logger: {name} -> {log_file_path}")
+                
+            except Exception as e:
+                print(f"[django-cfg] ERROR creating modular logger for {name}: {e}")
         
-        # Add file handler if logging config exists
-        if hasattr(config, 'logging') and config.logging and config.logging.file_path:
-            logging_config['handlers']['file'] = {
-                'class': 'logging.FileHandler',
-                'filename': config.logging.file_path,
-                'formatter': 'verbose',
-            }
-            
-            # Add file handler to root and django_cfg loggers
-            logging_config['root']['handlers'].append('file')
-            logging_config['loggers']['django_cfg']['handlers'].append('file')
-        
-        return logging_config
+        return logger
 
 
 # Convenience function for quick access
 def get_logger(name: str = "django_cfg") -> logging.Logger:
     """
-    Get a configured logger instance.
+    Get a configured logger instance with automatic django-cfg prefix detection.
     
-    Args:
-        name: Logger name (default: "django_cfg")
-        
-    Returns:
-        Configured logger instance
+    If called from django-cfg modules, automatically prefixes with 'django_cfg.'
     """
+    import inspect
+    
+    # Auto-detect if we're being called from django-cfg code
+    if not name.startswith('django_cfg'):
+        # Get the calling frame to determine if we're in django-cfg code
+        frame = inspect.currentframe()
+        try:
+            # Go up the call stack to find the actual caller
+            caller_frame = frame.f_back
+            if caller_frame:
+                caller_filename = caller_frame.f_code.co_filename
+                
+                # Check if caller is from django-cfg modules
+                if '/django_cfg/' in caller_filename:
+                    # Extract module path from filename
+                    # e.g., /path/to/django_cfg/apps/payments/services/providers/registry.py
+                    # -> django_cfg.payments.providers
+                    
+                    parts = caller_filename.split('/django_cfg/')
+                    if len(parts) > 1:
+                        module_path = parts[1]  # apps/payments/services/providers/registry.py
+                        
+                        # Convert path to module name
+                        if module_path.startswith('apps/'):
+                            # apps/payments/services/providers/registry.py -> payments.providers
+                            path_parts = module_path.split('/')[1:]  # Remove 'apps'
+                            if path_parts:
+                                # Remove file extension and 'services' if present
+                                clean_parts = []
+                                for part in path_parts[:-1]:  # Exclude filename
+                                    if part not in ['services', 'management', 'commands']:
+                                        clean_parts.append(part)
+                                
+                                if clean_parts:
+                                    auto_name = f"django_cfg.{'.'.join(clean_parts)}"
+                                    print(f"[django-cfg] Auto-detected logger name: {name} -> {auto_name}")
+                                    name = auto_name
+                        
+                        elif module_path.startswith('modules/'):
+                            # modules/django_logger.py -> django_cfg.core
+                            name = "django_cfg.core"
+                            
+                        elif module_path.startswith('core/'):
+                            # core/config.py -> django_cfg.core
+                            name = "django_cfg.core"
+        finally:
+            del frame
+    
     return DjangoLogger.get_logger(name)
 
 
 # Export public API
-__all__ = ['DjangoLogger', 'get_logger']
+__all__ = ['DjangoLogger', 'get_logger']

django_cfg/modules/django_unfold/dashboard.py

@@ -145,7 +145,7 @@ class DashboardManager(BaseCfgModule):
                 collapsible=True,
                 items=[
                     NavigationItem(title="Task Queue", icon=Icons.QUEUE, link="/admin/django_dramatiq/task/"),
-                    NavigationItem(title="Task Dashboard", icon=Icons.SETTINGS_APPLICATIONS, link="/cfg/tasks/dashboard/"),
+                    NavigationItem(title="Task Dashboard", icon=Icons.SETTINGS_APPLICATIONS, link="/cfg/admin/django_cfg_tasks/admin/dashboard/"),
                 ]
             ))
         
@@ -165,21 +165,74 @@ class DashboardManager(BaseCfgModule):
         
         # Add Payments section if enabled
         if self.is_payments_enabled():
+            try:
+                from django_cfg.models.payments import PaymentsConfig
+                config = PaymentsConfig.get_current_config()
+                
+                payments_items = []
+                
+                # Main dashboard (always show if payments app enabled)
+                payments_items.append(
+                    NavigationItem(title="Payment Dashboard", icon=Icons.DASHBOARD, link="/cfg/admin/django_cfg_payments/admin/")
+                )
+                
+                # Always show basic admin models (even if payments functionality is disabled)
+                payments_items.extend([
+                    NavigationItem(title="Payments", icon=Icons.ACCOUNT_BALANCE, link="/admin/payments/universalpayment/"),
+                    NavigationItem(title="Currencies", icon=Icons.CURRENCY_BITCOIN, link="/admin/payments/currency/"),
+                    NavigationItem(title="Currency Networks", icon=Icons.LINK, link="/admin/payments/network/"),
+                    NavigationItem(title="Provider Currencies", icon=Icons.ACCOUNT_CIRCLE, link="/admin/payments/providercurrency/"),
+                ])
+                
+                # Add advanced features only if payments functionality is enabled
+                if config.enabled:
+                    payments_items.append(
+                        NavigationItem(title="Webhook Dashboard", icon=Icons.WEBHOOK, link="/cfg/admin/django_cfg_payments/admin/webhooks/")
+                    )
+                    payments_items.append(
+                        NavigationItem(title="Create Payment", icon=Icons.ADD, link="/cfg/admin/django_cfg_payments/admin/payments/create/")
+                    )
+                    payments_items.append(
+                        NavigationItem(title="Currency Converter", icon=Icons.CURRENCY_EXCHANGE, link="/cfg/admin/django_cfg_payments/admin/tools/converter/")
+                    )
+                    
+                    # Show subscription features only if enabled
+                    if config.show_subscription_management():
+                        payments_items.extend([
+                            NavigationItem(title="Subscriptions", icon=Icons.PERSON_ADD, link="/admin/payments/subscription/"),
+                            NavigationItem(title="Tariffs", icon=Icons.PRICE_CHANGE, link="/admin/payments/tariff/"),
+                        ])
+                    
+                    # Show API management only if enabled
+                    if config.show_api_management():
+                        payments_items.extend([
+                            NavigationItem(title="API Keys", icon=Icons.KEY, link="/admin/payments/apikey/"),
+                            NavigationItem(title="Endpoint Groups", icon=Icons.GROUP, link="/admin/payments/endpointgroup/"),
+                        ])
+                    
+                    # Show balance/transaction features only if enabled
+                    if config.show_balance_management():
+                        payments_items.append(
+                            NavigationItem(title="Balances", icon=Icons.ACCOUNT_BALANCE_WALLET, link="/admin/payments/userbalance/")
+                        )
+                    
+                    if config.show_transaction_history():
+                        payments_items.append(
+                            NavigationItem(title="Transactions", icon=Icons.RECEIPT_LONG, link="/admin/payments/transaction/")
+                        )
+                
+            except Exception:
+                # Fallback
+                payments_items = [
+                    NavigationItem(title="Payment Dashboard", icon=Icons.DASHBOARD, link="/cfg/admin/django_cfg_payments/admin/"),
+                    NavigationItem(title="Payments", icon=Icons.ACCOUNT_BALANCE, link="/admin/payments/universalpayment/"),
+                ]
+            
             navigation_sections.append(NavigationSection(
                 title="Payments",
                 separator=True,
                 collapsible=True,
-                items=[
-                    NavigationItem(title="Payments", icon=Icons.ACCOUNT_BALANCE, link="/admin/django_cfg_payments/universalpayment/"),
-                    NavigationItem(title="Subscriptions", icon=Icons.PERSON_ADD, link="/admin/django_cfg_payments/subscription/"),
-                    NavigationItem(title="API Keys", icon=Icons.KEY, link="/admin/django_cfg_payments/apikey/"),
-                    NavigationItem(title="Balances", icon=Icons.ACCOUNT_BALANCE_WALLET, link="/admin/django_cfg_payments/userbalance/"),
-                    NavigationItem(title="Transactions", icon=Icons.DESCRIPTION, link="/admin/django_cfg_payments/transaction/"),
-                    NavigationItem(title="Currencies", icon=Icons.ACCOUNT_CIRCLE, link="/admin/django_cfg_payments/currency/"),
-                    NavigationItem(title="Currency Networks", icon=Icons.LINK, link="/admin/django_cfg_payments/currencynetwork/"),
-                    NavigationItem(title="Endpoint Groups", icon=Icons.GROUP, link="/admin/django_cfg_payments/endpointgroup/"),
-                    NavigationItem(title="Tariffs", icon=Icons.SETTINGS, link="/admin/django_cfg_payments/tariff/"),
-                ]
+                items=payments_items
             ))
         
         # Convert all NavigationSection objects to dictionaries

django_cfg/registry/core.py

@@ -5,6 +5,7 @@ Core Django-CFG components registry.
 CORE_REGISTRY = {
     # Core configuration
     "DjangoConfig": ("django_cfg.core.config", "DjangoConfig"),
+    "StartupInfoMode": ("django_cfg.core.config", "StartupInfoMode"),
     
     # Core exceptions
     "ConfigurationError": ("django_cfg.core.exceptions", "ConfigurationError"),

django_cfg/templates/admin/components/action_grid.html

@@ -1,26 +1,26 @@
 {% load unfold %}
 
 <!-- Action Grid Component -->
-<div class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-{{ cols|default:'3' }} xl:grid-cols-{{ xl_cols|default:'4' }} gap-4">
+<div class="grid grid-cols-1 md:grid-cols-2 gap-4">
     {% for action in actions %}
         <a href="{{ action.link }}" 
-           class="group flex items-center p-4 bg-white dark:bg-base-900 rounded-lg border border-base-200 dark:border-base-700 hover:border-primary-600 dark:hover:border-primary-500 hover:shadow-md transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-primary-500 focus:ring-offset-2">
+           class="group flex items-center p-4 theme-card rounded-lg border theme-border hover:border-blue-600 dark:hover:border-blue-500 hover:shadow-md transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2">
             
             <!-- Icon -->
             <div class="flex-shrink-0 mr-4">
                 <div class="p-2 rounded-lg transition-colors duration-200
-                    {% if action.color == 'primary' %}bg-primary-100 dark:bg-primary-900/20 group-hover:bg-primary-200 dark:group-hover:bg-primary-800/30
+                    {% if action.color == 'primary' %}bg-blue-100 dark:bg-blue-900/20 group-hover:bg-blue-200 dark:group-hover:bg-blue-800/30
                     {% elif action.color == 'success' %}bg-green-100 dark:bg-green-900/20 group-hover:bg-green-200 dark:group-hover:bg-green-800/30
                     {% elif action.color == 'warning' %}bg-amber-100 dark:bg-amber-900/20 group-hover:bg-amber-200 dark:group-hover:bg-amber-800/30
                     {% elif action.color == 'danger' %}bg-red-100 dark:bg-red-900/20 group-hover:bg-red-200 dark:group-hover:bg-red-800/30
-                    {% else %}bg-base-100 dark:bg-base-800 group-hover:bg-base-200 dark:group-hover:bg-base-700{% endif %}">
+                    {% else %}bg-gray-100 dark:bg-gray-800 group-hover:bg-gray-200 dark:group-hover:bg-gray-700{% endif %}">
                     
                     <span class="material-icons text-lg
-                        {% if action.color == 'primary' %}text-primary-600 dark:text-primary-400
+                        {% if action.color == 'primary' %}text-blue-600 dark:text-blue-400
                         {% elif action.color == 'success' %}text-green-600 dark:text-green-400
                         {% elif action.color == 'warning' %}text-amber-600 dark:text-amber-400
                         {% elif action.color == 'danger' %}text-red-600 dark:text-red-400
-                        {% else %}text-font-subtle-light dark:text-font-subtle-dark{% endif %}">
+                        {% else %}text-gray-600 dark:text-gray-400{% endif %}">
                         {{ action.icon }}
                     </span>
                 </div>
@@ -28,11 +28,11 @@
             
             <!-- Content -->
             <div class="flex-1 min-w-0">
-                <h3 class="text-sm font-medium text-font-default-light dark:text-font-default-dark group-hover:text-primary-600 dark:group-hover:text-primary-500 transition-colors duration-200">
+                <h3 class="text-sm font-medium theme-text group-hover:text-blue-600 dark:group-hover:text-blue-500 transition-colors duration-200">
                     {{ action.title }}
                 </h3>
                 {% if action.description %}
-                    <p class="text-xs text-font-subtle-light dark:text-font-subtle-dark mt-1 line-clamp-2">
+                    <p class="text-xs text-gray-500 dark:text-gray-400 mt-1 line-clamp-2">
                         {{ action.description }}
                     </p>
                 {% endif %}
@@ -40,7 +40,7 @@
             
             <!-- Arrow -->
             <div class="flex-shrink-0 ml-2">
-                <span class="material-icons text-base-400 dark:text-base-500 group-hover:text-primary-600 dark:group-hover:text-primary-500 transition-colors duration-200">
+                <span class="material-icons text-gray-400 dark:text-gray-500 group-hover:text-blue-600 dark:group-hover:text-blue-500 transition-colors duration-200">
                     arrow_forward
                 </span>
             </div>

django_cfg/templates/admin/components/metric_card.html

@@ -1,7 +1,7 @@
 {% load unfold %}
 
 <!-- Metric Card Component -->
-<div class="bg-white dark:bg-base-900 rounded-lg p-5 border border-base-200 dark:border-base-700 hover:shadow-md transition-shadow duration-200">
+<div class="theme-card rounded-lg p-5 border theme-border hover:shadow-md transition-shadow duration-200">
     <div class="flex items-center justify-between">
         <div class="flex items-center space-x-3">
             <div class="flex-shrink-0">
@@ -10,16 +10,16 @@
                     {% elif status == 'warning' %}text-amber-600 dark:text-amber-400
                     {% elif status == 'error' or status == 'failed' %}text-red-600 dark:text-red-400
                     {% elif status == 'info' %}text-blue-600 dark:text-blue-400
-                    {% else %}text-primary-600 dark:text-primary-400{% endif %}">
+                    {% else %}text-blue-600 dark:text-blue-400{% endif %}">
                     {{ icon }}
                 </span>
             </div>
-            <div>
-                <div class="text-sm font-medium text-font-default-light dark:text-font-default-dark">
+            <div class="min-w-0 flex-1">
+                <div class="text-sm font-medium theme-text truncate">
                     {{ title }}
                 </div>
                 {% if description %}
-                <div class="text-xs text-font-subtle-light dark:text-font-subtle-dark mt-1">
+                <div class="text-xs text-gray-500 dark:text-gray-400 mt-1 truncate">
                     {{ description }}
                 </div>
                 {% endif %}

django_cfg/templates/admin/components/status_badge.html

@@ -1,12 +1,12 @@
 {% load unfold %}
 
 <!-- Status Badge Component -->
-<span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium
+<span class="status-badge inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium
     {% if status == 'active' or status == 'healthy' or status == 'success' %}bg-green-100 dark:bg-green-900/20 text-green-600 dark:text-green-400
     {% elif status == 'warning' or status == 'pending' %}bg-amber-100 dark:bg-amber-900/20 text-amber-600 dark:text-amber-400
     {% elif status == 'error' or status == 'failed' or status == 'inactive' %}bg-red-100 dark:bg-red-900/20 text-red-600 dark:text-red-400
     {% elif status == 'info' or status == 'processing' %}bg-blue-100 dark:bg-blue-900/20 text-blue-600 dark:text-blue-400
-    {% else %}bg-base-100 dark:bg-base-800 text-font-subtle-light dark:text-font-subtle-dark{% endif %}">
+    {% else %}bg-gray-100 dark:bg-gray-800 text-gray-600 dark:text-gray-400{% endif %}">
     
     {% if icon %}
     <span class="material-icons text-xs mr-1">{{ icon }}</span>