django-cfg 1.3.13__py3-none-any.whl → 1.4.3__py3-none-any.whl

django_cfg/models/tasks/config.py

@@ -0,0 +1,314 @@
+"""
+Main task configuration models.
+
+Contains TaskConfig class (main entry point) and related enums.
+Size: ~250 lines (focused on main configuration)
+"""
+
+from pydantic import BaseModel, Field, field_validator
+from typing import Optional, List, Dict, Any
+from enum import Enum
+import os
+import logging
+
+from django_cfg.models.base import BaseCfgAutoModule
+
+logger = logging.getLogger(__name__)
+
+
+class TaskBackend(str, Enum):
+    """Supported task backends."""
+    DRAMATIQ = "dramatiq"
+    # Future: CELERY = "celery"
+
+
+class QueuePriority(str, Enum):
+    """Standard queue priorities."""
+    CRITICAL = "critical"
+    HIGH = "high"
+    DEFAULT = "default"
+    LOW = "low"
+    BACKGROUND = "background"
+
+
+class TaskConfig(BaseModel, BaseCfgAutoModule):
+    """
+    High-level task system configuration.
+
+    Main entry point for configuring background task processing in Django-CFG.
+    Provides environment-aware defaults and automatic Redis integration.
+
+    Example:
+        ```python
+        from django_cfg.models.tasks import TaskConfig
+
+        tasks = TaskConfig(
+            enabled=True,
+            backend=TaskBackend.DRAMATIQ,
+        )
+        ```
+    """
+
+    # === Core Settings ===
+    enabled: bool = Field(
+        default=True,
+        description="Enable background task processing"
+    )
+    backend: TaskBackend = Field(
+        default=TaskBackend.DRAMATIQ,
+        description="Task processing backend"
+    )
+
+    def __init__(self, **data):
+        """Initialize TaskConfig with BaseCfgAutoModule support."""
+        super().__init__(**data)
+        # Initialize _config attribute for BaseCfgAutoModule
+        self._config = None
+
+    # === Backend-Specific Configuration ===
+    dramatiq: 'DramatiqConfig' = Field(
+        default_factory=lambda: None,
+        description="Dramatiq-specific configuration"
+    )
+    worker: 'WorkerConfig' = Field(
+        default_factory=lambda: None,
+        description="Worker configuration"
+    )
+
+    def model_post_init(self, __context: Any) -> None:
+        """Initialize backend configs with defaults after model creation."""
+        if self.dramatiq is None:
+            from .backends import DramatiqConfig
+            self.dramatiq = DramatiqConfig()
+        if self.worker is None:
+            from .backends import WorkerConfig
+            self.worker = WorkerConfig()
+
+    # === Environment-Specific Overrides ===
+    dev_processes: Optional[int] = Field(
+        default=2,
+        description="Number of processes in development environment"
+    )
+    prod_processes: Optional[int] = Field(
+        default=None,
+        description="Number of processes in production environment"
+    )
+
+    # === Auto-Configuration ===
+    auto_discover_tasks: bool = Field(
+        default=True,
+        description="Automatically discover tasks in Django apps"
+    )
+    task_modules: List[str] = Field(
+        default=["tasks"],
+        description="Module names to search for tasks"
+    )
+
+    @field_validator("enabled")
+    @classmethod
+    def validate_enabled_with_environment(cls, v: bool) -> bool:
+        """Validate task system can be enabled in current environment."""
+        if v:
+            # Check if we're in a test environment
+            if os.getenv("DJANGO_SETTINGS_MODULE", "").endswith("test"):
+                logger.info("Task system disabled in test environment")
+                return False
+
+            # Additional environment checks can be added here
+            # For example, checking if Redis is available
+
+        return v
+
+    def get_effective_processes(self, debug: bool = False) -> int:
+        """
+        Get effective number of processes based on environment.
+
+        Args:
+            debug: Whether in debug mode
+
+        Returns:
+            Number of worker processes to use
+
+        Example:
+            >>> config = TaskConfig()
+            >>> config.get_effective_processes(debug=True)
+            2
+        """
+        if debug and self.dev_processes is not None:
+            return self.dev_processes
+        elif not debug and self.prod_processes is not None:
+            return self.prod_processes
+        else:
+            return self.dramatiq.processes
+
+    def get_effective_queues(self) -> List[str]:
+        """
+        Get effective queue configuration.
+
+        Returns:
+            List of queue names
+
+        Example:
+            >>> config = TaskConfig()
+            >>> config.get_effective_queues()
+            ['default', 'high', 'low']
+        """
+        return self.dramatiq.queues
+
+    def get_redis_config(self, redis_url: str) -> Dict[str, Any]:
+        """
+        Generate Redis configuration for Dramatiq.
+
+        Args:
+            redis_url: Redis connection URL
+
+        Returns:
+            Dictionary with Redis connection parameters
+
+        Example:
+            >>> config = TaskConfig()
+            >>> config.get_redis_config("redis://localhost:6379/1")
+            {'host': 'localhost', 'port': 6379, 'db': 1, 'password': None}
+        """
+        from urllib.parse import urlparse
+
+        # Parse Redis URL
+        parsed = urlparse(redis_url)
+
+        # Build Redis config
+        config = {
+            "host": parsed.hostname or "localhost",
+            "port": parsed.port or 6379,
+            "db": self.dramatiq.redis_db,
+            "password": parsed.password,
+        }
+
+        # Add SSL if specified
+        if parsed.scheme == "rediss":
+            config["ssl"] = True
+
+        return config
+
+    def get_dramatiq_settings(self, redis_url: str) -> Dict[str, Any]:
+        """
+        Generate complete Dramatiq settings for Django.
+
+        Args:
+            redis_url: Redis connection URL
+
+        Returns:
+            Dictionary with complete Dramatiq configuration
+
+        Example:
+            >>> config = TaskConfig()
+            >>> settings = config.get_dramatiq_settings("redis://localhost:6379/1")
+            >>> "DRAMATIQ_BROKER" in settings
+            True
+        """
+        from urllib.parse import urlparse
+
+        redis_config = self.get_redis_config(redis_url)
+        parsed = urlparse(redis_url)
+
+        # Build Redis URL with correct database
+        redis_url_with_db = redis_url
+        if parsed.path and parsed.path != "/":
+            # Replace existing database in URL
+            redis_url_with_db = redis_url.replace(parsed.path, f"/{self.dramatiq.redis_db}")
+        else:
+            # Add database to URL
+            redis_url_with_db = f"{redis_url.rstrip('/')}/{self.dramatiq.redis_db}"
+
+        return {
+            "DRAMATIQ_BROKER": {
+                "BROKER": "dramatiq.brokers.redis.RedisBroker",
+                "OPTIONS": {
+                    "url": redis_url_with_db,
+                    **redis_config
+                },
+            },
+            "DRAMATIQ_RESULT_BACKEND": {
+                "BACKEND": "dramatiq.results.backends.redis.RedisBackend",
+                "BACKEND_OPTIONS": {
+                    "url": redis_url_with_db,
+                    **redis_config
+                },
+            },
+            "DRAMATIQ_MIDDLEWARE": self.dramatiq.middleware,
+            "DRAMATIQ_QUEUES": self.dramatiq.queues,
+        }
+
+    def get_smart_defaults(self):
+        """
+        Get smart default configuration for this module.
+
+        Returns:
+            TaskConfig with smart defaults based on environment
+        """
+        from .utils import get_default_task_config
+
+        config = self.get_config()
+        debug = getattr(config, 'debug', False) if config else False
+        return get_default_task_config(debug=debug)
+
+    def get_module_config(self):
+        """
+        Get the final configuration for this module.
+
+        Returns:
+            Self (TaskConfig instance)
+        """
+        return self
+
+    @classmethod
+    def auto_initialize_if_needed(cls) -> Optional['TaskConfig']:
+        """
+        Auto-initialize TaskConfig if needed based on config flags.
+
+        Returns:
+            TaskConfig instance if should be initialized, None otherwise
+
+        Example:
+            >>> task_config = TaskConfig.auto_initialize_if_needed()
+            >>> if task_config:
+            ...     print("Tasks enabled")
+        """
+        # Get config through BaseCfgModule
+        from django_cfg.modules import BaseCfgModule
+        base_module = BaseCfgModule()
+        config = base_module.get_config()
+
+        if not config:
+            return None
+
+        # Check if TaskConfig already exists
+        if hasattr(config, 'tasks') and config.tasks is not None:
+            # Set config reference and return existing
+            config.tasks.set_config(config)
+            return config.tasks
+
+        # Check if tasks should be enabled
+        if config.should_enable_tasks():
+            # Auto-initialize with smart defaults
+            task_config = cls().get_smart_defaults()
+            task_config.set_config(config)
+            config.tasks = task_config
+
+            logger.info("🚀 Auto-initialized TaskConfig (enabled by knowbase/agents/tasks flags)")
+
+            return task_config
+
+        return None
+
+
+# Resolve forward references for Pydantic v2
+from .backends import DramatiqConfig, WorkerConfig
+TaskConfig.model_rebuild()
+
+__all__ = [
+    "TaskConfig",
+    "TaskBackend",
+    "QueuePriority",
+    "DramatiqConfig",
+    "WorkerConfig",
+]

django_cfg/models/tasks/utils.py

@@ -0,0 +1,174 @@
+"""
+Task configuration utilities.
+
+Contains utility functions for task configuration:
+- Smart queue detection
+- Environment-aware defaults
+- Configuration validation
+
+Size: ~120 lines (focused on utilities)
+"""
+
+from typing import List, Optional, TYPE_CHECKING
+import logging
+
+if TYPE_CHECKING:
+    from .config import TaskConfig
+
+logger = logging.getLogger(__name__)
+
+
+def get_smart_queues(debug: bool = False) -> List[str]:
+    """
+    Get smart default queues based on enabled modules.
+
+    Automatically detects which django-cfg modules are enabled and adds
+    their corresponding queues to the default queue list.
+
+    Args:
+        debug: Whether running in debug mode (affects base queues)
+
+    Returns:
+        List of queue names appropriate for enabled modules
+
+    Example:
+        >>> queues = get_smart_queues(debug=True)
+        >>> "default" in queues
+        True
+    """
+    # Base queues
+    if debug:
+        base_queues = ["default"]
+    else:
+        base_queues = ["critical", "high", "default", "low", "background"]
+
+    # Try to detect enabled modules and add their queues
+    try:
+        from django_cfg.modules.base import BaseCfgModule
+        base_module = BaseCfgModule()
+
+        # Check for knowbase module (requires "knowbase" queue)
+        if base_module.is_knowbase_enabled():
+            if "knowbase" not in base_queues:
+                base_queues.append("knowbase")
+
+        # Check for payments module (requires "payments" queue)
+        if base_module.is_payments_enabled():
+            if "payments" not in base_queues:
+                base_queues.append("payments")
+
+        # Check for agents module (may require "agents" queue in future)
+        if base_module.is_agents_enabled():
+            if "agents" not in base_queues:
+                base_queues.append("agents")
+
+        logger.info(f"🎯 Smart queue detection: {base_queues}")
+
+    except Exception as e:
+        logger.warning(f"Failed to auto-detect queues, using defaults: {e}")
+
+    return base_queues
+
+
+def get_default_task_config(debug: bool = False) -> 'TaskConfig':
+    """
+    Get default task configuration based on environment.
+
+    Creates a TaskConfig with sensible defaults for development or production.
+
+    Args:
+        debug: Whether in debug/development mode
+
+    Returns:
+        TaskConfig with environment-appropriate defaults
+
+    Example:
+        >>> config = get_default_task_config(debug=True)
+        >>> config.dramatiq.processes
+        2
+    """
+    from .config import TaskConfig
+    from .backends import DramatiqConfig, WorkerConfig
+
+    smart_queues = get_smart_queues(debug)
+
+    if debug:
+        # Development defaults
+        return TaskConfig(
+            dramatiq=DramatiqConfig(
+                processes=2,
+                threads=4,
+                prometheus_enabled=False,
+                queues=smart_queues,
+            ),
+            worker=WorkerConfig(
+                log_level="DEBUG",
+                health_check_enabled=False,
+            )
+        )
+    else:
+        # Production defaults
+        return TaskConfig(
+            dramatiq=DramatiqConfig(
+                processes=8,
+                threads=16,
+                prometheus_enabled=True,
+                queues=smart_queues,
+            ),
+            worker=WorkerConfig(
+                log_level="INFO",
+                health_check_enabled=True,
+                restart_on_memory_limit=True,
+            )
+        )
+
+
+def validate_task_config(config: 'TaskConfig', redis_url: Optional[str] = None) -> bool:
+    """
+    Validate task configuration and dependencies.
+
+    Checks if the task configuration is valid and all required dependencies are available.
+
+    Args:
+        config: TaskConfig to validate
+        redis_url: Optional Redis URL to validate
+
+    Returns:
+        True if configuration is valid, False otherwise
+
+    Example:
+        >>> config = get_default_task_config()
+        >>> validate_task_config(config, "redis://localhost:6379/1")
+        True
+    """
+    if not config.enabled:
+        return True
+
+    # Check Redis URL if provided
+    if redis_url:
+        try:
+            from urllib.parse import urlparse
+            parsed = urlparse(redis_url)
+            if not parsed.scheme.startswith("redis"):
+                logger.error(f"Invalid Redis URL scheme: {parsed.scheme}")
+                return False
+        except Exception as e:
+            logger.error(f"Invalid Redis URL: {e}")
+            return False
+
+    # Check if Dramatiq is available
+    try:
+        import dramatiq
+        import django_dramatiq
+    except ImportError as e:
+        logger.error(f"Dramatiq dependencies not available: {e}")
+        return False
+
+    return True
+
+
+__all__ = [
+    "get_smart_queues",
+    "get_default_task_config",
+    "validate_task_config",
+]

django_cfg/modules/base.py

@@ -178,16 +178,31 @@ class BaseCfgModule(ABC):
     def is_payments_enabled(self) -> bool:
         """
         Check if django-cfg Payments is enabled.
-        
+
         Returns:
             True if Payments is enabled, False otherwise
         """
         payments_config = self._get_config_key('payments', None)
-        
+
         # Only handle PaymentsConfig model
         if payments_config and hasattr(payments_config, 'enabled'):
             return payments_config.enabled
-        
+
+        return False
+
+    def is_rpc_enabled(self) -> bool:
+        """
+        Check if django-cfg RPC Client is enabled.
+
+        Returns:
+            True if RPC Client is enabled, False otherwise
+        """
+        rpc_config = self._get_config_key('django_ipc', None)
+
+        # Only handle DjangoCfgRPCConfig model
+        if rpc_config and hasattr(rpc_config, 'enabled'):
+            return rpc_config.enabled
+
         return False
 
 

django_cfg/modules/django_admin/decorators/actions.py

@@ -9,7 +9,7 @@ from functools import wraps
 from unfold.decorators import action as unfold_action
 from unfold.enums import ActionVariant as UnfoldActionVariant
 
-from django_cfg.modules.django_logger import get_logger
+from django_cfg.modules.django_logging import get_logger
 from ..models.action_models import ActionVariant
 
 

django_cfg/modules/django_admin/decorators/display.py

@@ -8,7 +8,7 @@ from typing import Optional, Callable, Any, Union
 from functools import wraps
 from django.utils.safestring import SafeString, mark_safe
 from unfold.decorators import display as unfold_display
-from django_cfg.modules.django_logger import get_logger
+from django_cfg.modules.django_logging import get_logger
 
 logger = get_logger('django_admin.decorators.display')
 

django_cfg/modules/django_admin/mixins/standalone_actions_mixin.py

@@ -14,7 +14,7 @@ import threading
 
 from unfold.decorators import action as unfold_action
 from unfold.enums import ActionVariant as UnfoldActionVariant
-from django_cfg.modules.django_logger import get_logger
+from django_cfg.modules.django_logging import get_logger
 from ..models.action_models import ActionVariant
 
 

django_cfg/modules/django_currency/examples/__init__.py

@@ -0,0 +1,3 @@
+"""
+Examples for currency module usage.
+"""

django_cfg/modules/django_currency/examples/example_database_usage.py

@@ -0,0 +1,144 @@
+"""
+Example usage of the database loader for populating currency data.
+"""
+
+import logging
+from .database_loader import (
+    CurrencyDatabaseLoader, 
+    DatabaseLoaderConfig,
+    create_database_loader,
+    load_currencies_to_database_format
+)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(name)s:%(levelname)s: %(message)s')
+
+
+def example_basic_usage():
+    """Basic example of using the database loader."""
+    print("🔄 Creating database loader...")
+    
+    # Create loader with default settings
+    loader = create_database_loader(
+        max_cryptocurrencies=100,  # Limit to top 100 cryptos
+        max_fiat_currencies=30,    # Top 30 fiat currencies
+        min_market_cap_usd=10_000_000,  # 10M USD minimum
+        coingecko_delay=2.0        # 2 second delay between requests
+    )
+    
+    # Get statistics
+    print("📊 Statistics:")
+    stats = loader.get_statistics()
+    for key, value in stats.items():
+        print(f"   {key}: {value}")
+    
+    print("\n🪙 Building currency database data...")
+    
+    # Build complete currency data
+    currencies = loader.build_currency_database_data()
+    
+    print(f"\n✅ Successfully loaded {len(currencies)} currencies")
+    
+    # Show sample data
+    print("\n📋 Sample currencies:")
+    for i, currency in enumerate(currencies[:10]):
+        print(f"   {i+1}. {currency.code} ({currency.currency_type}): "
+              f"{currency.name} = ${currency.usd_rate:.6f}")
+    
+    return currencies
+
+
+def example_django_integration():
+    """Example of how to integrate with Django ORM."""
+    print("🔄 Loading currencies in Django format...")
+    
+    # Get currencies in Django-ready format
+    currency_dicts = load_currencies_to_database_format()
+    
+    print(f"✅ Ready to insert {len(currency_dicts)} currencies into Django ORM")
+    
+    # This is how you would use it in Django:
+    print("\n💡 Django integration example:")
+    print("""
+    # In your Django management command or view:
+    from django_cfg.modules.django_currency.database_loader import load_currencies_to_database_format
+    from django_cfg.apps.payments.models import Currency
+    
+    # Load currency data
+    currency_data = load_currencies_to_database_format()
+    
+    # Bulk create currencies
+    currencies_to_create = []
+    for data in currency_data:
+        currency = Currency(**data)
+        currencies_to_create.append(currency)
+    
+    # Insert into database
+    Currency.objects.bulk_create(currencies_to_create, ignore_conflicts=True)
+    print(f"Inserted {len(currencies_to_create)} currencies")
+    """)
+    
+    return currency_dicts
+
+
+def example_advanced_config():
+    """Example with advanced configuration."""
+    print("🔧 Advanced configuration example...")
+    
+    # Custom configuration
+    config = DatabaseLoaderConfig(
+        # Rate limiting
+        coingecko_delay=3.0,           # Slower requests for stability
+        yfinance_delay=1.0,
+        max_requests_per_minute=20,    # Conservative rate limit
+        
+        # Limits
+        max_cryptocurrencies=50,       # Smaller set
+        max_fiat_currencies=20,
+        
+        # Filtering
+        min_market_cap_usd=50_000_000, # Higher threshold - 50M USD
+        exclude_stablecoins=True,      # Skip stablecoins
+        
+        # Cache
+        cache_ttl_hours=12            # Cache for 12 hours
+    )
+    
+    loader = CurrencyDatabaseLoader(config)
+    
+    print(f"📊 Configuration:")
+    print(f"   Max cryptocurrencies: {config.max_cryptocurrencies}")
+    print(f"   Min market cap: ${config.min_market_cap_usd:,.0f}")
+    print(f"   Exclude stablecoins: {config.exclude_stablecoins}")
+    print(f"   CoinGecko delay: {config.coingecko_delay}s")
+    
+    return loader
+
+
+if __name__ == "__main__":
+    print("🧪 CURRENCY DATABASE LOADER EXAMPLES")
+    print("=" * 50)
+    
+    try:
+        # Basic usage
+        print("\n1️⃣ BASIC USAGE:")
+        currencies = example_basic_usage()
+        
+        print("\n" + "=" * 50)
+        
+        # Django integration
+        print("\n2️⃣ DJANGO INTEGRATION:")
+        django_data = example_django_integration()
+        
+        print("\n" + "=" * 50)
+        
+        # Advanced config
+        print("\n3️⃣ ADVANCED CONFIGURATION:")
+        advanced_loader = example_advanced_config()
+        
+        print("\n🎉 All examples completed successfully!")
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        import traceback
+        traceback.print_exc()