django-cfg 1.2.31__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

@@ -165,26 +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="Payment Dashboard", icon=Icons.DASHBOARD, link="/cfg/admin/django_cfg_payments/admin/"),
-                    NavigationItem(title="Payment List", icon=Icons.LIST, link="/cfg/admin/django_cfg_payments/admin/list/"),
-                    NavigationItem(title="Create Payment", icon=Icons.ADD, link="/cfg/admin/django_cfg_payments/admin/create/"),
-                    NavigationItem(title="Payment Analytics", icon=Icons.ANALYTICS, link="/cfg/admin/django_cfg_payments/admin/stats/"),
-                    NavigationItem(title="Payment Testing", icon=Icons.SETTINGS, link="/cfg/admin/django_cfg_payments/admin/test/"),
-                    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/network/"),
-                    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"),