django-cfg 1.4.62__py3-none-any.whl → 1.4.64__py3-none-any.whl

django_cfg/apps/ipc/services/client/config.py

@@ -1,214 +0,0 @@
-"""
-Django-CFG RPC Client Configuration.
-
-Pydantic 2 configuration model for RPC client integration.
-Follows django-cfg patterns for modular configuration.
-"""
-
-from pydantic import BaseModel, Field, field_validator
-
-
-class DjangoCfgRPCConfig(BaseModel):
-    """
-    Django-CFG RPC Client configuration module.
-
-    Configures Redis-based RPC communication between Django and
-    django-cfg-rpc WebSocket servers.
-
-    Example:
-        >>> from django_cfg import DjangoConfig
-        >>> from django_cfg.modules.django_ipc_client import DjangoCfgRPCConfig
-        >>>
-        >>> config = DjangoConfig(
-        ...     django_ipc=DjangoCfgRPCConfig(
-        ...         enabled=True,
-        ...         redis_url="redis://localhost:6379/2",
-        ...         rpc_timeout=30
-        ...     )
-        ... )
-    """
-
-    # Module metadata
-    module_name: str = Field(
-        default="django_ipc_client",
-        frozen=True,
-        description="Module name for django-cfg integration",
-    )
-
-    enabled: bool = Field(
-        default=False,
-        description="Enable Django-CFG RPC client",
-    )
-
-    # Redis configuration
-    redis_url: str = Field(
-        default="redis://localhost:6379/2",
-        description="Redis URL for RPC communication (dedicated database recommended)",
-        examples=[
-            "redis://localhost:6379/2",
-            "redis://:password@localhost:6379/2",
-            "redis://redis-server:6379/2",
-        ],
-    )
-
-    redis_max_connections: int = Field(
-        default=50,
-        ge=10,
-        le=500,
-        description="Maximum Redis connection pool size",
-    )
-
-    # RPC settings
-    rpc_timeout: int = Field(
-        default=30,
-        ge=5,
-        le=300,
-        description="Default RPC call timeout (seconds)",
-    )
-
-    request_stream: str = Field(
-        default="stream:requests",
-        min_length=1,
-        max_length=100,
-        description="Redis Stream name for RPC requests",
-    )
-
-    consumer_group: str = Field(
-        default="rpc_group",
-        min_length=1,
-        max_length=100,
-        description="Redis Streams consumer group name (on server side)",
-    )
-
-    stream_maxlen: int = Field(
-        default=10000,
-        ge=1000,
-        le=100000,
-        description="Maximum stream length (XADD MAXLEN)",
-    )
-
-    # Response settings
-    response_key_prefix: str = Field(
-        default="list:response:",
-        min_length=1,
-        max_length=50,
-        description="Prefix for response list keys",
-    )
-
-    response_key_ttl: int = Field(
-        default=60,
-        ge=10,
-        le=3600,
-        description="Response key TTL (seconds) for auto-cleanup",
-    )
-
-    # Performance settings
-    enable_connection_pooling: bool = Field(
-        default=True,
-        description="Enable Redis connection pooling",
-    )
-
-    socket_keepalive: bool = Field(
-        default=True,
-        description="Enable TCP keepalive for Redis connections",
-    )
-
-    # Logging settings
-    log_rpc_calls: bool = Field(
-        default=False,
-        description="Log all RPC calls (verbose, use for debugging)",
-    )
-
-    log_level: str = Field(
-        default="INFO",
-        pattern=r"^(DEBUG|INFO|WARNING|ERROR|CRITICAL)$",
-        description="Log level for RPC module",
-    )
-
-    @field_validator("redis_url")
-    @classmethod
-    def validate_redis_url(cls, v: str) -> str:
-        """
-        Validate Redis URL format.
-
-        Allows environment variable templates like ${VAR:-default}.
-
-        Args:
-            v: Redis URL to validate
-
-        Returns:
-            Validated Redis URL
-
-        Raises:
-            ValueError: If URL format is invalid
-        """
-        # Skip validation for environment variable templates
-        if v.startswith("${") and "}" in v:
-            return v
-
-        # Validate actual URLs
-        if not v.startswith("redis://") and not v.startswith("rediss://"):
-            raise ValueError(
-                "redis_url must start with 'redis://' or 'rediss://' "
-                f"(got: {v})"
-            )
-
-        return v
-
-    def to_django_settings(self) -> dict:
-        """
-        Generate Django settings dictionary.
-
-        Returns:
-            Dictionary with DJANGO_CFG_RPC settings
-
-        Example:
-            >>> config = DjangoCfgRPCConfig(enabled=True)
-            >>> settings_dict = config.to_django_settings()
-            >>> print(settings_dict["DJANGO_CFG_RPC"]["REDIS_URL"])
-        """
-        if not self.enabled:
-            return {}
-
-        return {
-            "DJANGO_CFG_RPC": {
-                "ENABLED": self.enabled,
-                "REDIS_URL": self.redis_url,
-                "REDIS_MAX_CONNECTIONS": self.redis_max_connections,
-                "RPC_TIMEOUT": self.rpc_timeout,
-                "REQUEST_STREAM": self.request_stream,
-                "CONSUMER_GROUP": self.consumer_group,
-                "STREAM_MAXLEN": self.stream_maxlen,
-                "RESPONSE_KEY_PREFIX": self.response_key_prefix,
-                "RESPONSE_KEY_TTL": self.response_key_ttl,
-                "LOG_RPC_CALLS": self.log_rpc_calls,
-                "LOG_LEVEL": self.log_level,
-            }
-        }
-
-    def get_redis_config(self) -> dict:
-        """
-        Get Redis connection configuration.
-
-        Returns:
-            Dictionary with Redis connection options
-
-        Example:
-            >>> config = DjangoCfgRPCConfig()
-            >>> redis_config = config.get_redis_config()
-            >>> import redis
-            >>> redis_client = redis.Redis.from_url(**redis_config)
-        """
-        config = {
-            "url": self.redis_url,
-            "max_connections": self.redis_max_connections,
-            "decode_responses": False,  # We handle JSON ourselves
-        }
-
-        if self.socket_keepalive:
-            config["socket_keepalive"] = True
-
-        return config
-
-
-__all__ = ["DjangoCfgRPCConfig"]

django_cfg/apps/ipc/services/client/exceptions.py

@@ -1,201 +0,0 @@
-"""
-Custom Exceptions for Django-CFG RPC Client.
-
-Provides specific exception types for better error handling and debugging.
-Works independently or with django-cfg-rpc models.
-"""
-
-from typing import Any, Optional
-
-# Try to import RPCError from django-cfg-rpc if available
-try:
-    from django_ipc.models.errors import RPCError
-    HAS_DJANGO_CFG_RPC = True
-except ImportError:
-    # Fallback: simple RPCError for basic error handling
-    HAS_DJANGO_CFG_RPC = False
-
-    class RPCError:  # type: ignore
-        """Minimal RPCError fallback when django-cfg-rpc not installed."""
-
-        def __init__(self, code: str, message: str, retryable: bool = False, retry_after: Optional[int] = None):
-            self.code = code
-            self.message = message
-            self.retryable = retryable
-            self.retry_after = retry_after
-
-
-class RPCBaseException(Exception):
-    """
-    Base exception for all RPC-related errors.
-
-    All custom RPC exceptions inherit from this class.
-    """
-
-    def __init__(self, message: str):
-        """
-        Initialize base RPC exception.
-
-        Args:
-            message: Error message
-        """
-        self.message = message
-        super().__init__(message)
-
-
-class RPCTimeoutError(RPCBaseException):
-    """
-    RPC call timed out waiting for response.
-
-    Raised when BLPOP timeout is exceeded.
-
-    Example:
-        >>> try:
-        ...     result = rpc.call(method="slow", params=..., timeout=5)
-        ... except RPCTimeoutError as e:
-        ...     print(f"RPC timeout: {e.message}")
-        ...     print(f"Timeout duration: {e.timeout_seconds}s")
-    """
-
-    def __init__(self, message: str, method: str, timeout_seconds: int):
-        """
-        Initialize timeout error.
-
-        Args:
-            message: Error message
-            method: RPC method that timed out
-            timeout_seconds: Timeout duration that was exceeded
-        """
-        super().__init__(message)
-        self.method = method
-        self.timeout_seconds = timeout_seconds
-
-    def __str__(self) -> str:
-        """String representation."""
-        return f"RPC timeout on method '{self.method}' after {self.timeout_seconds}s: {self.message}"
-
-
-class RPCRemoteError(RPCBaseException):
-    """
-    Remote RPC execution failed.
-
-    Raised when server returns error response.
-
-    Example:
-        >>> try:
-        ...     result = rpc.call(method="...", params=...)
-        ... except RPCRemoteError as e:
-        ...     print(f"Remote error: {e.error.code}")
-        ...     print(f"Message: {e.error.message}")
-        ...     if e.is_retryable:
-        ...         print(f"Can retry after {e.retry_after}s")
-    """
-
-    def __init__(self, error: Any):
-        """
-        Initialize remote error.
-
-        Args:
-            error: Structured RPC error from server (RPCError or dict)
-        """
-        # Handle both RPCError objects and dicts
-        if isinstance(error, dict):
-            message = error.get("message", "Unknown error")
-            self.error = RPCError(
-                code=error.get("code", "internal_error"),
-                message=message,
-                retryable=error.get("retryable", False),
-                retry_after=error.get("retry_after"),
-            )
-        else:
-            message = error.message if hasattr(error, "message") else str(error)
-            self.error = error
-
-        super().__init__(message)
-
-    def __str__(self) -> str:
-        """String representation."""
-        code = self.error.code if hasattr(self.error, "code") else "unknown"
-        return f"RPC remote error [{code}]: {self.message}"
-
-    @property
-    def is_retryable(self) -> bool:
-        """Check if error is retryable."""
-        return getattr(self.error, "retryable", False)
-
-    @property
-    def retry_after(self) -> Optional[int]:
-        """Get retry delay in seconds."""
-        return getattr(self.error, "retry_after", None)
-
-
-class RPCConnectionError(RPCBaseException):
-    """
-    Failed to connect to Redis.
-
-    Raised when Redis connection fails.
-
-    Example:
-        >>> try:
-        ...     rpc = DjangoCfgRPCClient(redis_url="redis://invalid:6379")
-        ... except RPCConnectionError as e:
-        ...     print(f"Connection failed: {e.message}")
-    """
-
-    def __init__(self, message: str, redis_url: Optional[str] = None):
-        """
-        Initialize connection error.
-
-        Args:
-            message: Error message
-            redis_url: Redis URL that failed to connect
-        """
-        super().__init__(message)
-        self.redis_url = redis_url
-
-    def __str__(self) -> str:
-        """String representation."""
-        if self.redis_url:
-            return f"RPC connection error to {self.redis_url}: {self.message}"
-        return f"RPC connection error: {self.message}"
-
-
-class RPCConfigurationError(RPCBaseException):
-    """
-    RPC configuration error.
-
-    Raised when RPC client is misconfigured.
-
-    Example:
-        >>> try:
-        ...     rpc = get_rpc_client()  # No config in settings
-        ... except RPCConfigurationError as e:
-        ...     print(f"Configuration error: {e.message}")
-    """
-
-    def __init__(self, message: str, config_key: Optional[str] = None):
-        """
-        Initialize configuration error.
-
-        Args:
-            message: Error message
-            config_key: Configuration key that is missing/invalid
-        """
-        super().__init__(message)
-        self.config_key = config_key
-
-    def __str__(self) -> str:
-        """String representation."""
-        if self.config_key:
-            return f"RPC configuration error (key: {self.config_key}): {self.message}"
-        return f"RPC configuration error: {self.message}"
-
-
-__all__ = [
-    "RPCBaseException",
-    "RPCTimeoutError",
-    "RPCRemoteError",
-    "RPCConnectionError",
-    "RPCConfigurationError",
-    "HAS_DJANGO_CFG_RPC",
-]

django_cfg/apps/ipc/services/logging.py

@@ -1,239 +0,0 @@
-"""
-RPC Logging helper for tracking RPC calls.
-
-Provides async-safe logging of RPC calls to database.
-"""
-
-import time
-from typing import Any, Dict, Optional
-from django.conf import settings
-from django_cfg.modules.django_logging import get_logger
-
-logger = get_logger("ipc.rpc")
-
-
-class RPCLogger:
-    """
-    Helper class for logging RPC calls to database.
-
-    Usage:
-        >>> log_entry = RPCLogger.create_log(
-        ...     correlation_id="abc123",
-        ...     method="send_notification",
-        ...     params={"user_id": "123"},
-        ...     user=request.user if authenticated else None
-        ... )
-        >>> # ... make RPC call ...
-        >>> RPCLogger.mark_success(log_entry, response_data, duration_ms=150)
-    """
-
-    @staticmethod
-    def is_logging_enabled() -> bool:
-        """
-        Check if RPC logging is enabled in settings.
-
-        Returns:
-            bool: True if logging is enabled
-        """
-        # Check if IPC app is installed
-        if 'django_cfg.apps.ipc' not in settings.INSTALLED_APPS:
-            return False
-
-        # Check if logging is explicitly disabled
-        if hasattr(settings, 'DJANGO_CFG_RPC'):
-            return settings.DJANGO_CFG_RPC.get('ENABLE_LOGGING', True)
-
-        return True
-
-    @staticmethod
-    def create_log(
-        correlation_id: str,
-        method: str,
-        params: Dict[str, Any],
-        user: Optional[Any] = None,
-        caller_ip: Optional[str] = None,
-        user_agent: Optional[str] = None,
-    ):
-        """
-        Create RPC log entry in pending state.
-
-        Args:
-            correlation_id: UUID correlation ID from RPC request
-            method: RPC method name
-            params: Parameters sent to RPC method
-            user: Django User instance (optional)
-            caller_ip: IP address of caller (optional)
-            user_agent: User agent string (optional)
-
-        Returns:
-            RPCLog instance or None if logging disabled
-        """
-        if not RPCLogger.is_logging_enabled():
-            return None
-
-        try:
-            from ..models import RPCLog
-
-            log_entry = RPCLog.objects.create(
-                correlation_id=correlation_id,
-                method=method,
-                params=params,
-                user=user,
-                caller_ip=caller_ip,
-                user_agent=user_agent,
-                status=RPCLog.StatusChoices.PENDING
-            )
-            return log_entry
-
-        except Exception as e:
-            logger.error(f"Failed to create RPC log: {e}", exc_info=True)
-            return None
-
-    @staticmethod
-    def mark_success(log_entry, response_data: Dict[str, Any], duration_ms: Optional[int] = None):
-        """
-        Mark RPC log as successful.
-
-        Args:
-            log_entry: RPCLog instance
-            response_data: Response data from RPC call
-            duration_ms: Duration in milliseconds (optional)
-        """
-        if log_entry is None:
-            return
-
-        try:
-            log_entry.mark_success(response_data, duration_ms)
-        except Exception as e:
-            logger.error(f"Failed to mark RPC log as success: {e}", exc_info=True)
-
-    @staticmethod
-    def mark_failed(log_entry, error_code: str, error_message: str, duration_ms: Optional[int] = None):
-        """
-        Mark RPC log as failed.
-
-        Args:
-            log_entry: RPCLog instance
-            error_code: Error code
-            error_message: Error message
-            duration_ms: Duration in milliseconds (optional)
-        """
-        if log_entry is None:
-            return
-
-        try:
-            log_entry.mark_failed(error_code, error_message, duration_ms)
-        except Exception as e:
-            logger.error(f"Failed to mark RPC log as failed: {e}", exc_info=True)
-
-    @staticmethod
-    def mark_timeout(log_entry, timeout_seconds: int):
-        """
-        Mark RPC log as timed out.
-
-        Args:
-            log_entry: RPCLog instance
-            timeout_seconds: Timeout duration in seconds
-        """
-        if log_entry is None:
-            return
-
-        try:
-            log_entry.mark_timeout(timeout_seconds)
-        except Exception as e:
-            logger.error(f"Failed to mark RPC log as timeout: {e}", exc_info=True)
-
-
-class RPCLogContext:
-    """
-    Context manager for automatically logging RPC calls.
-
-    Usage:
-        >>> with RPCLogContext(
-        ...     correlation_id="abc123",
-        ...     method="send_notification",
-        ...     params={"user_id": "123"}
-        ... ) as log_ctx:
-        ...     result = rpc.call(...)
-        ...     log_ctx.set_response(result)
-    """
-
-    def __init__(
-        self,
-        correlation_id: str,
-        method: str,
-        params: Dict[str, Any],
-        user: Optional[Any] = None,
-        caller_ip: Optional[str] = None,
-        user_agent: Optional[str] = None,
-    ):
-        """
-        Initialize RPC log context.
-
-        Args:
-            correlation_id: UUID correlation ID
-            method: RPC method name
-            params: Parameters for RPC call
-            user: Django User instance (optional)
-            caller_ip: IP address (optional)
-            user_agent: User agent string (optional)
-        """
-        self.correlation_id = correlation_id
-        self.method = method
-        self.params = params
-        self.user = user
-        self.caller_ip = caller_ip
-        self.user_agent = user_agent
-        self.log_entry = None
-        self.start_time = None
-        self.response = None
-
-    def __enter__(self):
-        """Start timing and create log entry."""
-        self.start_time = time.time()
-        self.log_entry = RPCLogger.create_log(
-            correlation_id=self.correlation_id,
-            method=self.method,
-            params=self.params,
-            user=self.user,
-            caller_ip=self.caller_ip,
-            user_agent=self.user_agent,
-        )
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Mark log as success or failed based on exception."""
-        if self.log_entry is None:
-            return False
-
-        duration_ms = int((time.time() - self.start_time) * 1000) if self.start_time else None
-
-        if exc_type is None:
-            # Success - use response if set
-            RPCLogger.mark_success(self.log_entry, self.response or {}, duration_ms)
-        else:
-            # Failed - extract error details
-            error_code = exc_type.__name__ if exc_type else 'unknown'
-            error_message = str(exc_val) if exc_val else 'Unknown error'
-
-            # Check if it's a timeout
-            if 'timeout' in error_code.lower():
-                timeout_seconds = duration_ms // 1000 if duration_ms else 30
-                RPCLogger.mark_timeout(self.log_entry, timeout_seconds)
-            else:
-                RPCLogger.mark_failed(self.log_entry, error_code, error_message, duration_ms)
-
-        # Don't suppress exceptions
-        return False
-
-    def set_response(self, response: Dict[str, Any]):
-        """
-        Set response data for successful call.
-
-        Args:
-            response: Response data from RPC call
-        """
-        self.response = response
-
-
-__all__ = ['RPCLogger', 'RPCLogContext']