django-cfg 1.4.48__py3-none-any.whl → 1.5.7__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",
-]