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

django_cfg/modules/django_tasks/settings.py

@@ -0,0 +1,107 @@
+"""
+Dramatiq settings generation.
+
+Functions to generate Dramatiq settings from DjangoConfig.
+"""
+
+from typing import Optional, Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def generate_dramatiq_settings_from_config(config=None) -> Optional[Dict[str, Any]]:
+    """
+    Generate Dramatiq settings from DjangoConfig instance.
+
+    Args:
+        config: DjangoConfig instance (optional, will auto-discover if not provided)
+
+    Returns:
+        Dict[str, Any]: Dramatiq settings dictionary or None if not enabled
+    """
+    # If config provided, use it directly
+    if config is not None:
+        try:
+            if not hasattr(config, "tasks") or not config.tasks or not config.tasks.enabled:
+                return None
+
+            # Get Redis URL from cache configuration
+            redis_url = None
+            if config.cache_default and hasattr(config.cache_default, 'redis_url'):
+                redis_url = config.cache_default.redis_url
+            elif config.cache_default and hasattr(config.cache_default, 'location'):
+                redis_url = config.cache_default.location
+            else:
+                redis_url = "redis://localhost:6379"
+
+            if redis_url:
+                dramatiq_settings = config.tasks.get_dramatiq_settings(redis_url)
+                logger.debug(f"Generated Dramatiq settings with Redis URL: {redis_url}")
+                return dramatiq_settings
+            else:
+                logger.warning("Tasks enabled but no Redis URL available for Dramatiq")
+                return None
+
+        except Exception as e:
+            logger.error(f"Failed to generate Dramatiq settings: {e}")
+            return None
+
+    # Auto-discover config if not provided
+    try:
+        from ..base import BaseCfgModule
+
+        base_module = BaseCfgModule()
+        config = base_module.get_config()
+
+        if not config or not hasattr(config, 'tasks') or not config.tasks or not config.tasks.enabled:
+            return None
+
+        # Get Redis URL from cache config or environment
+        redis_url = None
+        if hasattr(config, 'cache_default') and config.cache_default:
+            redis_url = getattr(config.cache_default, 'redis_url', None)
+
+        if not redis_url:
+            # Fallback to environment or default
+            import os
+            redis_url = os.getenv('REDIS_URL', 'redis://localhost:6379/1')
+
+        # Generate Dramatiq settings
+        dramatiq_settings = config.tasks.get_dramatiq_settings(redis_url)
+
+        # Ensure we only use Redis broker (no RabbitMQ)
+        if 'DRAMATIQ_BROKER' in dramatiq_settings:
+            dramatiq_settings['DRAMATIQ_BROKER']['BROKER'] = 'dramatiq.brokers.redis.RedisBroker'
+
+        logger.info(f"✅ Generated Dramatiq settings with Redis broker and {len(config.tasks.dramatiq.queues)} queues")
+        return dramatiq_settings
+
+    except Exception as e:
+        logger.error(f"Failed to generate Dramatiq settings: {e}")
+        return None
+
+
+def extend_constance_config_with_tasks():
+    """Extend Constance configuration with Dramatiq task fields if tasks are enabled."""
+    try:
+        from .factory import get_task_service
+
+        service = get_task_service()
+        if not service.is_enabled():
+            logger.debug("Task system not enabled, skipping Constance extension")
+            return []
+
+        fields = service.get_constance_fields()
+        logger.info(f"🔧 Extended Constance with {len(fields)} task configuration fields")
+        return fields
+
+    except Exception as e:
+        logger.error(f"Failed to extend Constance config with tasks: {e}")
+        return []
+
+
+__all__ = [
+    "generate_dramatiq_settings_from_config",
+    "extend_constance_config_with_tasks",
+]

django_cfg/modules/django_telegram/__init__.py

@@ -0,0 +1,29 @@
+"""
+Django Telegram Service for django_cfg.
+
+Auto-configuring Telegram notification service that integrates with DjangoConfig.
+"""
+
+from .service import (
+    TelegramParseMode,
+    TelegramError,
+    TelegramConfigError,
+    TelegramSendError,
+    DjangoTelegram,
+)
+from .utils import (
+    send_telegram_message,
+    send_telegram_photo,
+    send_telegram_document,
+)
+
+__all__ = [
+    "TelegramParseMode",
+    "TelegramError",
+    "TelegramConfigError",
+    "TelegramSendError",
+    "DjangoTelegram",
+    "send_telegram_message",
+    "send_telegram_photo",
+    "send_telegram_document",
+]

django_cfg/modules/{django_telegram.py → django_telegram/service.py}

@@ -5,11 +5,10 @@ Auto-configuring Telegram notification service that integrates with DjangoConfig
 """
 
 import logging
-import time
-from typing import Optional, Dict, Any, Union, List, BinaryIO
+from typing import Optional, Dict, Any, Union, BinaryIO
 from enum import Enum
 import yaml
-from django_cfg.modules import BaseCfgModule
+from ..base import BaseCfgModule
 from django_cfg.core.exceptions import ConfigurationError
 import telebot
 
@@ -26,19 +25,16 @@ class TelegramParseMode(Enum):
 
 class TelegramError(Exception):
     """Base exception for Telegram-related errors."""
-
     pass
 
 
 class TelegramConfigError(TelegramError):
     """Raised when configuration is missing or invalid."""
-
     pass
 
 
 class TelegramSendError(TelegramError):
     """Raised when message sending fails."""
-
     pass
 
 
@@ -91,7 +87,6 @@ class DjangoTelegram(BaseCfgModule):
 
         if self._bot is None:
             try:
-
                 telegram_config = self.config.telegram
                 self._bot = telebot.TeleBot(telegram_config.bot_token)
             except ImportError:
@@ -116,7 +111,7 @@ class DjangoTelegram(BaseCfgModule):
             "configured": True,
             "bot_token": f"{telegram_config.bot_token[:10]}..." if telegram_config.bot_token else "Not set",
             "chat_id": telegram_config.chat_id or "Not set",
-            "enabled": True,  # Always enabled if configured
+            "enabled": True,
             "parse_mode": telegram_config.parse_mode or "None",
         }
 
@@ -152,8 +147,6 @@ class DjangoTelegram(BaseCfgModule):
                 return False
 
             telegram_config = self.config.telegram
-
-            # Use provided chat_id or fall back to config
             target_chat_id = chat_id or telegram_config.chat_id
             if not target_chat_id:
                 error_msg = "No chat_id provided and none configured"
@@ -162,20 +155,17 @@ class DjangoTelegram(BaseCfgModule):
                     raise TelegramConfigError(error_msg)
                 return False
 
-            # Use provided parse_mode or fall back to config
             target_parse_mode = parse_mode or telegram_config.parse_mode
-            
+
             # Handle both enum and string parse modes
             if target_parse_mode:
                 if isinstance(target_parse_mode, TelegramParseMode):
                     parse_mode_str = target_parse_mode.value
                 else:
-                    # If it's already a string from config, use it directly
                     parse_mode_str = target_parse_mode
             else:
                 parse_mode_str = None
 
-            # Send message
             self.bot.send_message(
                 chat_id=target_chat_id,
                 text=message,
@@ -234,13 +224,12 @@ class DjangoTelegram(BaseCfgModule):
                 return False
 
             target_parse_mode = parse_mode or telegram_config.parse_mode
-            
+
             # Handle both enum and string parse modes
             if target_parse_mode:
                 if isinstance(target_parse_mode, TelegramParseMode):
                     parse_mode_str = target_parse_mode.value
                 else:
-                    # If it's already a string from config, use it directly
                     parse_mode_str = target_parse_mode
             else:
                 parse_mode_str = None
@@ -302,13 +291,12 @@ class DjangoTelegram(BaseCfgModule):
                 return False
 
             target_parse_mode = parse_mode or telegram_config.parse_mode
-            
+
             # Handle both enum and string parse modes
             if target_parse_mode:
                 if isinstance(target_parse_mode, TelegramParseMode):
                     parse_mode_str = target_parse_mode.value
                 else:
-                    # If it's already a string from config, use it directly
                     parse_mode_str = target_parse_mode
             else:
                 parse_mode_str = None
@@ -360,8 +348,6 @@ class DjangoTelegram(BaseCfgModule):
     def _format_to_yaml(cls, data: Dict[str, Any]) -> str:
         """Format dictionary data as YAML string."""
         try:
-            import yaml
-
             yaml_str = yaml.safe_dump(
                 data,
                 default_flow_style=False,
@@ -372,59 +358,50 @@ class DjangoTelegram(BaseCfgModule):
             return yaml_str
         except Exception as e:
             logger.error(f"Error formatting to YAML: {str(e)}")
-            # Final fallback to string representation
             return str(data)
 
     @classmethod
     def send_error(cls, error: str, context: Optional[Dict[str, Any]] = None) -> None:
-        """Send error notification.
-
-        Args:
-            error: Error message
-            context: Optional context data
-        """
-        telegram = cls()
-        text = f"{cls.EMOJI_MAP['error']} <b>Error</b>\n\n{error}"
-        if context:
-            text += "\n\n<pre>" + cls._format_to_yaml(context) + "</pre>"
-        telegram.send_message(text, parse_mode=TelegramParseMode.HTML)
+        """Send error notification."""
+        try:
+            telegram = cls()
+            text = f"{cls.EMOJI_MAP['error']} <b>Error</b>\n\n{error}"
+            if context:
+                text += "\n\n<pre>" + cls._format_to_yaml(context) + "</pre>"
+            telegram.send_message(text, parse_mode=TelegramParseMode.HTML)
+        except Exception:
+            # Silently fail - error notifications should not cause cascading failures
+            pass
 
     @classmethod
     def send_success(cls, message: str, details: Optional[Dict[str, Any]] = None) -> None:
-        """Send success notification.
-
-        Args:
-            message: Success message
-            details: Optional details
-        """
-        telegram = cls()
-        text = f"{cls.EMOJI_MAP['success']} <b>Success</b>\n\n{message}"
-        if details:
-            text += "\n\n<pre>" + cls._format_to_yaml(details) + "</pre>"
-        telegram.send_message(text, parse_mode=TelegramParseMode.HTML)
+        """Send success notification."""
+        try:
+            telegram = cls()
+            text = f"{cls.EMOJI_MAP['success']} <b>Success</b>\n\n{message}"
+            if details:
+                text += "\n\n<pre>" + cls._format_to_yaml(details) + "</pre>"
+            telegram.send_message(text, parse_mode=TelegramParseMode.HTML)
+        except Exception:
+            # Silently fail - success notifications should not cause failures
+            pass
 
     @classmethod
     def send_warning(cls, warning: str, context: Optional[Dict[str, Any]] = None) -> None:
-        """Send warning notification.
-
-        Args:
-            warning: Warning message
-            context: Optional context data
-        """
-        telegram = cls()
-        text = f"{cls.EMOJI_MAP['warning']} <b>Warning</b>\n\n{warning}"
-        if context:
-            text += "\n\n<pre>" + cls._format_to_yaml(context) + "</pre>"
-        telegram.send_message(text, parse_mode=TelegramParseMode.HTML)
+        """Send warning notification."""
+        try:
+            telegram = cls()
+            text = f"{cls.EMOJI_MAP['warning']} <b>Warning</b>\n\n{warning}"
+            if context:
+                text += "\n\n<pre>" + cls._format_to_yaml(context) + "</pre>"
+            telegram.send_message(text, parse_mode=TelegramParseMode.HTML)
+        except Exception:
+            # Silently fail - warning notifications should not cause failures
+            pass
 
     @classmethod
     def send_info(cls, message: str, data: Optional[Dict[str, Any]] = None) -> None:
-        """Send informational message.
-
-        Args:
-            message: Info message
-            data: Optional data
-        """
+        """Send informational message."""
         telegram = cls()
         text = f"{cls.EMOJI_MAP['info']} <b>Info</b>\n\n{message}"
         if data:
@@ -433,62 +410,17 @@ class DjangoTelegram(BaseCfgModule):
 
     @classmethod
     def send_stats(cls, title: str, stats: Dict[str, Any]) -> None:
-        """Send statistics data.
-
-        Args:
-            title: Stats title
-            stats: Statistics data
-        """
+        """Send statistics data."""
         telegram = cls()
         text = f"{cls.EMOJI_MAP['stats']} <b>{title}</b>"
         text += "\n\n<pre>" + cls._format_to_yaml(stats) + "</pre>"
         telegram.send_message(text, parse_mode=TelegramParseMode.HTML)
 
 
-# Convenience functions for direct usage
-def send_telegram_message(
-    message: str,
-    chat_id: Optional[Union[int, str]] = None,
-    parse_mode: Optional[TelegramParseMode] = None,
-    fail_silently: bool = False,
-) -> bool:
-    """Send a Telegram message using auto-configured service."""
-    telegram = DjangoTelegram()
-    return telegram.send_message(
-        message=message,
-        chat_id=chat_id,
-        parse_mode=parse_mode,
-        fail_silently=fail_silently,
-    )
-
-
-def send_telegram_photo(
-    photo: Union[str, BinaryIO],
-    caption: Optional[str] = None,
-    chat_id: Optional[Union[int, str]] = None,
-    fail_silently: bool = False,
-) -> bool:
-    """Send a Telegram photo using auto-configured service."""
-    telegram = DjangoTelegram()
-    return telegram.send_photo(
-        photo=photo,
-        caption=caption,
-        chat_id=chat_id,
-        fail_silently=fail_silently,
-    )
-
-
-def send_telegram_document(
-    document: Union[str, BinaryIO],
-    caption: Optional[str] = None,
-    chat_id: Optional[Union[int, str]] = None,
-    fail_silently: bool = False,
-) -> bool:
-    """Send a Telegram document using auto-configured service."""
-    telegram = DjangoTelegram()
-    return telegram.send_document(
-        document=document,
-        caption=caption,
-        chat_id=chat_id,
-        fail_silently=fail_silently,
-    )
+__all__ = [
+    "TelegramParseMode",
+    "TelegramError",
+    "TelegramConfigError",
+    "TelegramSendError",
+    "DjangoTelegram",
+]

django_cfg/modules/django_telegram/utils.py

@@ -0,0 +1,62 @@
+"""
+Telegram utilities and convenience functions.
+"""
+
+from typing import Optional, Union, BinaryIO
+
+from .service import DjangoTelegram, TelegramParseMode
+
+
+def send_telegram_message(
+    message: str,
+    chat_id: Optional[Union[int, str]] = None,
+    parse_mode: Optional[TelegramParseMode] = None,
+    fail_silently: bool = False,
+) -> bool:
+    """Send a Telegram message using auto-configured service."""
+    telegram = DjangoTelegram()
+    return telegram.send_message(
+        message=message,
+        chat_id=chat_id,
+        parse_mode=parse_mode,
+        fail_silently=fail_silently,
+    )
+
+
+def send_telegram_photo(
+    photo: Union[str, BinaryIO],
+    caption: Optional[str] = None,
+    chat_id: Optional[Union[int, str]] = None,
+    fail_silently: bool = False,
+) -> bool:
+    """Send a Telegram photo using auto-configured service."""
+    telegram = DjangoTelegram()
+    return telegram.send_photo(
+        photo=photo,
+        caption=caption,
+        chat_id=chat_id,
+        fail_silently=fail_silently,
+    )
+
+
+def send_telegram_document(
+    document: Union[str, BinaryIO],
+    caption: Optional[str] = None,
+    chat_id: Optional[Union[int, str]] = None,
+    fail_silently: bool = False,
+) -> bool:
+    """Send a Telegram document using auto-configured service."""
+    telegram = DjangoTelegram()
+    return telegram.send_document(
+        document=document,
+        caption=caption,
+        chat_id=chat_id,
+        fail_silently=fail_silently,
+    )
+
+
+__all__ = [
+    "send_telegram_message",
+    "send_telegram_photo",
+    "send_telegram_document",
+]

django_cfg/modules/django_twilio/__init__.py

@@ -13,134 +13,81 @@ Features:
 - Type-safe configuration with Pydantic v2
 """
 
-from typing import TYPE_CHECKING
+# Configuration
+from django_cfg.modules.django_twilio.models import TwilioConfig
 
-if TYPE_CHECKING:
-    from django_cfg.modules.django_twilio.models import TwilioConfig
-    from django_cfg.modules.django_twilio.service import (
-        DjangoTwilioService,
-        WhatsAppOTPService,
-        EmailOTPService,
-        SMSOTPService,
-        UnifiedOTPService,
-    )
-    from django_cfg.modules.django_twilio.simple_service import SimpleTwilioService
-    from django_cfg.modules.django_twilio.exceptions import (
-        TwilioError,
-        TwilioConfigurationError,
-        TwilioVerificationError,
-        TwilioSendError,
-    )
+# Services
+from django_cfg.modules.django_twilio.base import BaseTwilioService, is_async_context
+from django_cfg.modules.django_twilio.whatsapp import WhatsAppOTPService
+from django_cfg.modules.django_twilio.email_otp import EmailOTPService
+from django_cfg.modules.django_twilio.sms import SMSOTPService
+from django_cfg.modules.django_twilio.unified import UnifiedOTPService, DjangoTwilioService
 
+# Simple messaging service
+from django_cfg.modules.django_twilio.simple_service import SimpleTwilioService
 
-def __getattr__(name: str):
-    """Lazy import mechanism for Twilio module components."""
-    
-    # Configuration model
-    if name == "TwilioConfig":
-        from django_cfg.modules.django_twilio.models import TwilioConfig
-        return TwilioConfig
-    
-    # Main service
-    elif name == "DjangoTwilioService":
-        from django_cfg.modules.django_twilio.service import DjangoTwilioService
-        return DjangoTwilioService
-    
-    # Simple service
-    elif name == "SimpleTwilioService":
-        from django_cfg.modules.django_twilio.simple_service import SimpleTwilioService
-        return SimpleTwilioService
-    
-    # Specialized services
-    elif name == "WhatsAppOTPService":
-        from django_cfg.modules.django_twilio.service import WhatsAppOTPService
-        return WhatsAppOTPService
-    
-    elif name == "EmailOTPService":
-        from django_cfg.modules.django_twilio.service import EmailOTPService
-        return EmailOTPService
-    
-    elif name == "SMSOTPService":
-        from django_cfg.modules.django_twilio.service import SMSOTPService
-        return SMSOTPService
-    
-    elif name == "UnifiedOTPService":
-        from django_cfg.modules.django_twilio.service import UnifiedOTPService
-        return UnifiedOTPService
-    
-    # Exceptions
-    elif name == "TwilioError":
-        from django_cfg.modules.django_twilio.exceptions import TwilioError
-        return TwilioError
-    
-    elif name == "TwilioConfigurationError":
-        from django_cfg.modules.django_twilio.exceptions import TwilioConfigurationError
-        return TwilioConfigurationError
-    
-    elif name == "TwilioVerificationError":
-        from django_cfg.modules.django_twilio.exceptions import TwilioVerificationError
-        return TwilioVerificationError
-    
-    elif name == "TwilioSendError":
-        from django_cfg.modules.django_twilio.exceptions import TwilioSendError
-        return TwilioSendError
-    
-    # Convenience functions
-    elif name == "send_whatsapp_otp":
-        from django_cfg.modules.django_twilio.service import send_whatsapp_otp
-        return send_whatsapp_otp
-    
-    elif name == "send_email_otp":
-        from django_cfg.modules.django_twilio.service import send_email_otp
-        return send_email_otp
-    
-    elif name == "send_sms_otp":
-        from django_cfg.modules.django_twilio.service import send_sms_otp
-        return send_sms_otp
-    
-    elif name == "verify_otp":
-        from django_cfg.modules.django_twilio.service import verify_otp
-        return verify_otp
-    
-    # Simple service convenience functions
-    elif name == "send_whatsapp":
-        from django_cfg.modules.django_twilio.simple_service import send_whatsapp
-        return send_whatsapp
-    
-    elif name == "send_sms":
-        from django_cfg.modules.django_twilio.simple_service import send_sms
-        return send_sms
-    
-    else:
-        raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+# Exceptions
+from django_cfg.modules.django_twilio.exceptions import (
+    TwilioError,
+    TwilioConfigurationError,
+    TwilioVerificationError,
+    TwilioSendError,
+)
+
+# Convenience functions
+from django_cfg.modules.django_twilio.utils import (
+    send_whatsapp_otp,
+    send_email_otp,
+    send_sms_otp,
+    verify_otp,
+    asend_whatsapp_otp,
+    asend_email_otp,
+    asend_sms_otp,
+    averify_otp,
+)
+
+# Simple messaging convenience functions
+try:
+    from django_cfg.modules.django_twilio.simple_service import send_whatsapp, send_sms
+except ImportError:
+    send_whatsapp = None
+    send_sms = None
 
 
 # Public API
 __all__ = [
     # Configuration
     "TwilioConfig",
-    
+
     # Services
     "DjangoTwilioService",
     "SimpleTwilioService",
-    "WhatsAppOTPService", 
+    "WhatsAppOTPService",
     "EmailOTPService",
     "SMSOTPService",
     "UnifiedOTPService",
-    
+    "BaseTwilioService",
+
     # Exceptions
     "TwilioError",
-    "TwilioConfigurationError", 
+    "TwilioConfigurationError",
     "TwilioVerificationError",
     "TwilioSendError",
-    
+
     # OTP functions
     "send_whatsapp_otp",
-    "send_email_otp", 
+    "send_email_otp",
     "send_sms_otp",
     "verify_otp",
-    
-    # Simple messaging functions
-    "send_whatsapp",
-    "send_sms",
+    "asend_whatsapp_otp",
+    "asend_email_otp",
+    "asend_sms_otp",
+    "averify_otp",
+
+    # Utility functions
+    "is_async_context",
 ]
+
+# Add simple messaging if available
+if send_whatsapp is not None:
+    __all__.extend(["send_whatsapp", "send_sms"])