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

django_cfg/models/payments/providers/base.py

@@ -0,0 +1,25 @@
+"""
+Base provider configuration for payment providers.
+"""
+
+from pydantic import BaseModel, Field
+from typing import Dict
+
+
+class BaseProviderConfig(BaseModel):
+    """Base configuration for payment providers."""
+
+    provider_name: str = Field(..., description="Provider name")
+    enabled: bool = Field(default=True, description="Whether provider is enabled")
+
+    def get_provider_config(self) -> Dict[str, any]:
+        """Get provider-specific configuration."""
+        return {
+            'provider_name': self.provider_name,
+            'enabled': self.enabled,
+        }
+
+
+__all__ = [
+    "BaseProviderConfig",
+]

django_cfg/models/payments/providers/nowpayments.py

@@ -0,0 +1,48 @@
+"""
+NowPayments provider configuration.
+"""
+
+from pydantic import Field
+from typing import Dict
+from .base import BaseProviderConfig
+
+
+class NowPaymentsProviderConfig(BaseProviderConfig):
+    """NowPayments provider configuration."""
+
+    provider_name: str = Field(default="nowpayments", description="Provider name")
+    api_key: str = Field(default="", description="NowPayments API key")
+    ipn_secret: str = Field(default="", description="NowPayments IPN secret for webhook validation")
+    sandbox_mode: bool = Field(default=True, description="NowPayments sandbox mode")
+
+    def get_provider_config(self) -> Dict[str, any]:
+        """Get NowPayments-specific configuration."""
+        return {
+            'provider_name': self.provider_name,
+            'enabled': self.enabled and bool(self.api_key.strip()),
+            'api_key': self.api_key,
+            'ipn_secret': self.ipn_secret,
+            'sandbox_mode': self.sandbox_mode,
+        }
+
+
+# Future provider configs (commented out for now)
+# class StripeProviderConfig(BaseProviderConfig):
+#     """Stripe provider configuration."""
+#
+#     provider_name: str = Field(default="stripe", description="Provider name")
+#     api_key: str = Field(default="", description="Stripe API key")
+#     webhook_secret: str = Field(default="", description="Stripe webhook secret")
+#
+#     def get_provider_config(self) -> Dict[str, any]:
+#         return {
+#             'provider_name': self.provider_name,
+#             'enabled': self.enabled and bool(self.api_key.strip()),
+#             'api_key': self.api_key,
+#             'webhook_secret': self.webhook_secret,
+#         }
+
+
+__all__ = [
+    "NowPaymentsProviderConfig",
+]

django_cfg/models/services/__init__.py

@@ -0,0 +1,18 @@
+"""
+Service configuration models for django_cfg.
+
+Provides type-safe configuration for various services:
+- EmailConfig: Email/SMTP configuration
+- TelegramConfig: Telegram bot configuration
+- ServiceConfig: Generic service configuration
+"""
+
+from .email import EmailConfig
+from .telegram import TelegramConfig
+from .base import ServiceConfig
+
+__all__ = [
+    "EmailConfig",
+    "TelegramConfig",
+    "ServiceConfig",
+]

django_cfg/models/services/base.py

@@ -0,0 +1,65 @@
+"""
+Base service configuration for django_cfg.
+
+Generic service configuration for custom services.
+"""
+
+from typing import Dict, Any
+from pydantic import BaseModel, Field, field_validator
+
+
+class ServiceConfig(BaseModel):
+    """
+    Generic service configuration for custom services.
+
+    This is a fallback for services that don't have specialized models.
+    Prefer specific models like EmailConfig, TelegramConfig when available.
+    """
+
+    model_config = {
+        "str_strip_whitespace": True,
+        "validate_assignment": True,
+        "extra": "allow",  # Allow additional fields for flexibility
+    }
+
+    name: str = Field(
+        ...,
+        description="Service name",
+        min_length=1,
+        max_length=50,
+    )
+
+    enabled: bool = Field(
+        default=True,
+        description="Whether service is enabled",
+    )
+
+    config: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Service-specific configuration",
+    )
+
+    @field_validator('name')
+    @classmethod
+    def validate_name(cls, v: str) -> str:
+        """Validate service name format."""
+        if not v.replace('_', '').replace('-', '').isalnum():
+            raise ValueError(
+                "Service name must contain only alphanumeric characters, "
+                "underscores, and hyphens"
+            )
+
+        return v
+
+    def to_config_dict(self) -> Dict[str, Any]:
+        """Convert to configuration dictionary."""
+        return {
+            'name': self.name,
+            'enabled': self.enabled,
+            **self.config,
+        }
+
+
+__all__ = [
+    "ServiceConfig",
+]

django_cfg/models/{email.py → services/email.py}

@@ -6,7 +6,7 @@ Django email settings with Pydantic 2.
 
 from typing import Dict, Any, Optional
 from pydantic import Field, field_validator
-from .base import BaseConfig
+from ..base import BaseConfig
 
 
 class EmailConfig(BaseConfig):

django_cfg/models/services/telegram.py

@@ -0,0 +1,172 @@
+"""
+Telegram service configuration for django_cfg.
+
+Type-safe Telegram bot configuration with validation.
+"""
+
+from typing import Dict, Optional, Any, Literal
+from pydantic import BaseModel, Field, field_validator
+
+
+class TelegramConfig(BaseModel):
+    """
+    Type-safe Telegram bot configuration.
+
+    Supports Telegram Bot API for notifications and alerts.
+    """
+
+    model_config = {
+        "str_strip_whitespace": True,
+        "validate_assignment": True,
+        "extra": "forbid",
+    }
+
+    # Bot configuration
+    bot_token: str = Field(
+        ...,
+        description="Telegram bot token from @BotFather",
+        min_length=10,
+        repr=False,  # Don't show in repr for security
+    )
+
+    chat_id: int = Field(
+        ...,
+        description="Telegram chat ID for notifications",
+    )
+
+    # Message settings
+    parse_mode: Literal["HTML", "Markdown", "MarkdownV2", None] = Field(
+        default="HTML",
+        description="Message parse mode",
+    )
+
+    disable_notification: bool = Field(
+        default=False,
+        description="Send messages silently",
+    )
+
+    disable_web_page_preview: bool = Field(
+        default=False,
+        description="Disable link previews in messages",
+    )
+
+    # Connection settings
+    timeout: int = Field(
+        default=30,
+        description="Request timeout in seconds",
+        ge=1,
+        le=300,
+    )
+
+    # Webhook settings (optional)
+    webhook_url: Optional[str] = Field(
+        default=None,
+        description="Webhook URL for receiving updates",
+    )
+
+    webhook_secret: Optional[str] = Field(
+        default=None,
+        description="Webhook secret token",
+        repr=False,
+    )
+
+    # Rate limiting
+    max_retries: int = Field(
+        default=3,
+        description="Maximum retry attempts for failed requests",
+        ge=0,
+        le=10,
+    )
+
+    retry_delay: float = Field(
+        default=1.0,
+        description="Delay between retry attempts in seconds",
+        ge=0.1,
+        le=60.0,
+    )
+
+    @field_validator('bot_token')
+    @classmethod
+    def validate_bot_token(cls, v: str) -> str:
+        """Validate Telegram bot token format."""
+        # Basic format validation: should be digits:alphanumeric
+        if ':' not in v:
+            raise ValueError("Invalid bot token format: missing ':' separator")
+
+        parts = v.split(':', 1)
+        if len(parts) != 2:
+            raise ValueError("Invalid bot token format: should be 'bot_id:token'")
+
+        bot_id, token = parts
+
+        # Validate bot ID (should be numeric)
+        if not bot_id.isdigit():
+            raise ValueError("Invalid bot token: bot ID must be numeric")
+
+        # Validate token length (should be around 35 characters)
+        if len(token) < 30:
+            raise ValueError("Invalid bot token: token too short")
+
+        return v
+
+    @field_validator('chat_id')
+    @classmethod
+    def validate_chat_id(cls, v: int) -> int:
+        """Validate Telegram chat ID."""
+        # Chat IDs can be negative (groups/channels) or positive (users)
+        # Just check it's not zero
+        if v == 0:
+            raise ValueError("Chat ID cannot be zero")
+
+        return v
+
+    @field_validator('webhook_url')
+    @classmethod
+    def validate_webhook_url(cls, v: Optional[str]) -> Optional[str]:
+        """Validate webhook URL format."""
+        if v is None:
+            return v
+
+        if not v.startswith('https://'):
+            raise ValueError("Webhook URL must use HTTPS")
+
+        from urllib.parse import urlparse
+        try:
+            parsed = urlparse(v)
+            if not parsed.netloc:
+                raise ValueError("Invalid webhook URL: missing domain")
+        except Exception as e:
+            raise ValueError(f"Invalid webhook URL: {e}") from e
+
+        return v
+
+    def to_config_dict(self) -> Dict[str, Any]:
+        """
+        Convert to configuration dictionary.
+
+        Returns:
+            Telegram configuration dictionary
+        """
+        config = {
+            'bot_token': self.bot_token,
+            'chat_id': self.chat_id,
+            'parse_mode': self.parse_mode,
+            'disable_notification': self.disable_notification,
+            'disable_web_page_preview': self.disable_web_page_preview,
+            'timeout': self.timeout,
+            'max_retries': self.max_retries,
+            'retry_delay': self.retry_delay,
+        }
+
+        if self.webhook_url:
+            config['webhook_url'] = self.webhook_url
+
+        if self.webhook_secret:
+            config['webhook_secret'] = self.webhook_secret
+
+        return config
+
+
+__all__ = [
+    "TelegramConfig",
+]

django_cfg/models/tasks/__init__.py

@@ -0,0 +1,51 @@
+"""
+Task processing configuration models for Django-CFG.
+
+This module provides type-safe Pydantic models for configuring background task
+processing with Dramatiq, including worker management, queue configuration,
+and monitoring settings.
+
+Architecture:
+    config.py - Main TaskConfig and enums
+    backends.py - DramatiqConfig and WorkerConfig
+    utils.py - Utility functions
+
+Example:
+    ```python
+    from django_cfg.models.tasks import TaskConfig, DramatiqConfig
+
+    # Basic configuration
+    tasks = TaskConfig(
+        enabled=True,
+        dramatiq=DramatiqConfig(
+            processes=4,
+            threads=8,
+            queues=["default", "high", "low"],
+        )
+    )
+
+    # Get environment-aware defaults
+    from django_cfg.models.tasks import get_default_task_config
+    tasks = get_default_task_config(debug=True)
+    ```
+"""
+
+from .config import TaskConfig, TaskBackend, QueuePriority
+from .backends import DramatiqConfig, WorkerConfig
+from .utils import get_default_task_config, validate_task_config, get_smart_queues
+
+__all__ = [
+    # Main configuration
+    "TaskConfig",
+    "TaskBackend",
+    "QueuePriority",
+
+    # Backend configurations
+    "DramatiqConfig",
+    "WorkerConfig",
+
+    # Utility functions
+    "get_default_task_config",
+    "validate_task_config",
+    "get_smart_queues",
+]

django_cfg/models/tasks/backends.py

@@ -0,0 +1,250 @@
+"""
+Backend-specific configurations.
+
+Contains Dramatiq and Worker configuration models.
+Size: ~200 lines (focused on backend settings)
+"""
+
+from pydantic import BaseModel, Field, field_validator
+from typing import Optional, List, Literal
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class DramatiqConfig(BaseModel):
+    """
+    Dramatiq-specific configuration with production-ready defaults.
+
+    This model provides comprehensive configuration for Dramatiq background
+    task processing, including Redis settings, worker configuration,
+    middleware stack, and monitoring options.
+
+    Example:
+        ```python
+        from django_cfg.models.tasks import DramatiqConfig
+
+        dramatiq = DramatiqConfig(
+            redis_db=1,
+            processes=4,
+            threads=8,
+        )
+        ```
+    """
+
+    # === Redis Configuration ===
+    redis_db: int = Field(
+        default=1,
+        ge=0,
+        le=15,
+        description="Redis database number for tasks (separate from cache)"
+    )
+    redis_key_prefix: str = Field(
+        default="dramatiq",
+        description="Redis key prefix for task data"
+    )
+
+    # === Task Configuration ===
+    max_retries: int = Field(
+        default=3,
+        ge=0,
+        le=10,
+        description="Default maximum retry count for failed tasks"
+    )
+    default_priority: int = Field(
+        default=5,
+        ge=0,
+        le=10,
+        description="Default task priority (0=highest, 10=lowest)"
+    )
+    max_age_seconds: int = Field(
+        default=3600,
+        ge=60,
+        description="Maximum age for tasks before they expire"
+    )
+    time_limit_seconds: int = Field(
+        default=600,
+        ge=30,
+        description="Maximum execution time per task"
+    )
+
+    # === Worker Configuration ===
+    processes: int = Field(
+        default=4,
+        ge=1,
+        le=32,
+        description="Number of worker processes"
+    )
+    threads: int = Field(
+        default=8,
+        ge=1,
+        le=64,
+        description="Number of threads per worker process"
+    )
+    queues: List[str] = Field(
+        default=["default", "high", "low"],
+        description="Available task queues"
+    )
+
+    # === Middleware Stack ===
+    middleware: List[str] = Field(
+        default=[
+            "dramatiq.middleware.AgeLimit",
+            "dramatiq.middleware.TimeLimit",
+            "dramatiq.middleware.Callbacks",
+            "dramatiq.middleware.Retries",
+            "dramatiq.middleware.Prometheus",
+            "django_dramatiq.middleware.AdminMiddleware",
+            "django_dramatiq.middleware.DbConnectionsMiddleware",
+        ],
+        description="Middleware stack for task processing"
+    )
+
+    # === Monitoring & Admin ===
+    prometheus_enabled: bool = Field(
+        default=True,
+        description="Enable Prometheus metrics collection"
+    )
+    admin_enabled: bool = Field(
+        default=True,
+        description="Enable Django admin interface integration"
+    )
+
+    # === Performance Tuning ===
+    prefetch_multiplier: int = Field(
+        default=2,
+        ge=1,
+        le=10,
+        description="Message prefetch multiplier for workers"
+    )
+    max_memory_mb: Optional[int] = Field(
+        default=512,
+        ge=128,
+        description="Maximum memory usage per worker (MB)"
+    )
+
+    @field_validator("processes")
+    @classmethod
+    def validate_processes(cls, v: int) -> int:
+        """Ensure reasonable process count based on CPU cores."""
+        cpu_count = os.cpu_count() or 4
+        max_recommended = cpu_count * 2
+
+        if v > max_recommended:
+            logger.warning(
+                f"Process count ({v}) exceeds recommended maximum ({max_recommended}). "
+                f"Consider reducing to avoid resource contention."
+            )
+
+        return v
+
+    @field_validator("queues")
+    @classmethod
+    def validate_queues(cls, v: List[str]) -> List[str]:
+        """Ensure queue names are valid and include default."""
+        if not v:
+            raise ValueError("At least one queue must be specified")
+
+        # Ensure 'default' queue exists
+        if "default" not in v:
+            v.append("default")
+
+        # Validate queue names (alphanumeric + underscore/hyphen)
+        import re
+        pattern = re.compile(r'^[a-zA-Z0-9_-]+$')
+
+        for queue in v:
+            if not pattern.match(queue):
+                raise ValueError(f"Invalid queue name: {queue}. Use only alphanumeric, underscore, and hyphen.")
+
+        return v
+
+    @field_validator("middleware")
+    @classmethod
+    def validate_middleware(cls, v: List[str]) -> List[str]:
+        """Ensure essential middleware is included."""
+        essential_middleware = [
+            "dramatiq.middleware.Retries",
+            "django_dramatiq.middleware.DbConnectionsMiddleware",
+        ]
+
+        for middleware in essential_middleware:
+            if middleware not in v:
+                logger.warning(f"Adding essential middleware: {middleware}")
+                v.append(middleware)
+
+        return v
+
+
+class WorkerConfig(BaseModel):
+    """
+    Worker process and resource configuration.
+
+    Provides fine-grained control over worker behavior, resource limits,
+    and health monitoring settings.
+
+    Example:
+        ```python
+        from django_cfg.models.tasks import WorkerConfig
+
+        worker = WorkerConfig(
+            shutdown_timeout=30,
+            max_memory_mb=512,
+            health_check_enabled=True,
+        )
+        ```
+    """
+
+    # === Process Management ===
+    shutdown_timeout: int = Field(
+        default=30,
+        ge=5,
+        le=300,
+        description="Graceful shutdown timeout in seconds"
+    )
+    heartbeat_interval: int = Field(
+        default=5,
+        ge=1,
+        le=60,
+        description="Worker heartbeat interval in seconds"
+    )
+
+    # === Resource Limits ===
+    max_memory_mb: Optional[int] = Field(
+        default=512,
+        ge=128,
+        description="Maximum memory per worker process (MB)"
+    )
+    max_cpu_percent: Optional[float] = Field(
+        default=80.0,
+        ge=10.0,
+        le=100.0,
+        description="Maximum CPU usage per worker (%)"
+    )
+
+    # === Health Monitoring ===
+    health_check_enabled: bool = Field(
+        default=True,
+        description="Enable worker health monitoring"
+    )
+    restart_on_memory_limit: bool = Field(
+        default=True,
+        description="Restart worker if memory limit exceeded"
+    )
+
+    # === Logging ===
+    log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR"] = Field(
+        default="INFO",
+        description="Worker log level"
+    )
+    log_format: str = Field(
+        default="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        description="Log message format"
+    )
+
+
+__all__ = [
+    "DramatiqConfig",
+    "WorkerConfig",
+]