empathy-framework 2.4.0__py3-none-any.whl → 3.8.2__py3-none-any.whl

empathy_os/redis_config.py

@@ -1,8 +1,7 @@
-"""
-Redis Configuration for Empathy Framework
+"""Redis Configuration for Empathy Framework
 
 Handles connection to Redis from environment variables.
-Supports Railway, redis.com, local Docker, or mock mode.
+Supports Railway, redis.com, local Docker, managed Redis, or mock mode.
 
 Environment Variables:
     REDIS_URL: Full Redis URL (redis://user:pass@host:port)
@@ -12,8 +11,29 @@ Environment Variables:
     REDIS_DB: Redis database number (default: 0)
     EMPATHY_REDIS_MOCK: Set to "true" to use mock mode
 
+    # SSL/TLS (for managed Redis services)
+    REDIS_SSL: Set to "true" to enable SSL
+    REDIS_SSL_CERT_REQS: Certificate requirement ("required", "optional", "none")
+    REDIS_SSL_CA_CERTS: Path to CA certificate file
+    REDIS_SSL_CERTFILE: Path to client certificate
+    REDIS_SSL_KEYFILE: Path to client key
+
+    # Connection settings
+    REDIS_SOCKET_TIMEOUT: Socket timeout in seconds (default: 5.0)
+    REDIS_MAX_CONNECTIONS: Connection pool size (default: 10)
+
+    # Retry settings
+    REDIS_RETRY_MAX_ATTEMPTS: Max retry attempts (default: 3)
+    REDIS_RETRY_BASE_DELAY: Base retry delay in seconds (default: 0.1)
+    REDIS_RETRY_MAX_DELAY: Max retry delay in seconds (default: 2.0)
+
+    # Sentinel (for high availability)
+    REDIS_SENTINEL_HOSTS: Comma-separated host:port pairs
+    REDIS_SENTINEL_MASTER: Sentinel master name
+
 Railway Auto-Detection:
     When deployed on Railway, REDIS_URL is automatically set.
+    For Railway Redis with SSL, the URL starts with "rediss://"
 
 Usage:
     from empathy_os.redis_config import get_redis_memory
@@ -21,8 +41,13 @@ Usage:
     # Automatically uses environment variables
     memory = get_redis_memory()
 
-    # Or with explicit URL
-    memory = get_redis_memory(url="redis://localhost:6379")
+    # Or with explicit URL (SSL auto-detected from rediss://)
+    memory = get_redis_memory(url="rediss://user:pass@managed-redis.com:6379")
+
+    # Or with explicit config
+    from empathy_os.memory.short_term import RedisConfig
+    config = RedisConfig(host="localhost", ssl=True)
+    memory = get_redis_memory(config=config)
 
 Copyright 2025 Smart AI Memory, LLC
 Licensed under Fair Source 0.9
@@ -31,72 +56,126 @@ Licensed under Fair Source 0.9
 import os
 from urllib.parse import urlparse
 
-from .redis_memory import RedisShortTermMemory
+from .memory.short_term import RedisConfig, RedisShortTermMemory
 
 
 def parse_redis_url(url: str) -> dict:
-    """
-    Parse Redis URL into connection parameters.
+    """Parse Redis URL into connection parameters.
+
+    Supports:
+    - redis://user:pass@host:port/db (standard)
+    - rediss://user:pass@host:port/db (SSL enabled)
 
     Args:
-        url: Redis URL (redis://user:pass@host:port/db)
+        url: Redis URL (redis:// or rediss://)
 
     Returns:
-        Dict with host, port, password, db
+        Dict with host, port, password, db, ssl
+
     """
     parsed = urlparse(url)
 
+    # Detect SSL from scheme
+    ssl = parsed.scheme == "rediss"
+
     return {
         "host": parsed.hostname or "localhost",
         "port": parsed.port or 6379,
         "password": parsed.password,
         "db": int(parsed.path.lstrip("/") or 0) if parsed.path else 0,
+        "ssl": ssl,
     }
 
 
-def get_redis_config() -> dict:
-    """
-    Get Redis configuration from environment variables.
+def get_redis_config() -> RedisConfig:
+    """Get Redis configuration from environment variables.
 
     Priority:
-    1. REDIS_URL (full URL, used by Railway)
+    1. REDIS_URL (full URL, used by Railway/Heroku/managed services)
     2. Individual env vars (REDIS_HOST, REDIS_PORT, etc.)
     3. Defaults (localhost:6379)
 
     Returns:
-        Dict with connection parameters or {"use_mock": True}
+        RedisConfig with all connection parameters
+
     """
     # Check for mock mode
     if os.getenv("EMPATHY_REDIS_MOCK", "").lower() == "true":
-        return {"use_mock": True}
+        return RedisConfig(use_mock=True)
 
-    # Check for full URL (Railway, Heroku, etc.)
+    # Check for full URL (Railway, Heroku, managed services)
     redis_url = os.getenv("REDIS_URL") or os.getenv("REDIS_PRIVATE_URL")
     if redis_url:
-        config = parse_redis_url(redis_url)
-        config["use_mock"] = False
-        return config
+        url_config = parse_redis_url(redis_url)
+        return RedisConfig(
+            host=url_config["host"],
+            port=url_config["port"],
+            password=url_config["password"],
+            db=url_config["db"],
+            ssl=url_config.get("ssl", False),
+            use_mock=False,
+            # Apply additional env var overrides
+            socket_timeout=float(os.getenv("REDIS_SOCKET_TIMEOUT", "5.0")),
+            max_connections=int(os.getenv("REDIS_MAX_CONNECTIONS", "10")),
+            retry_max_attempts=int(os.getenv("REDIS_RETRY_MAX_ATTEMPTS", "3")),
+            retry_base_delay=float(os.getenv("REDIS_RETRY_BASE_DELAY", "0.1")),
+            retry_max_delay=float(os.getenv("REDIS_RETRY_MAX_DELAY", "2.0")),
+        )
+
+    # Build config from individual env vars
+    return RedisConfig(
+        host=os.getenv("REDIS_HOST", "localhost"),
+        port=int(os.getenv("REDIS_PORT", "6379")),
+        password=os.getenv("REDIS_PASSWORD"),
+        db=int(os.getenv("REDIS_DB", "0")),
+        use_mock=False,
+        # SSL settings
+        ssl=os.getenv("REDIS_SSL", "").lower() == "true",
+        ssl_cert_reqs=os.getenv("REDIS_SSL_CERT_REQS"),
+        ssl_ca_certs=os.getenv("REDIS_SSL_CA_CERTS"),
+        ssl_certfile=os.getenv("REDIS_SSL_CERTFILE"),
+        ssl_keyfile=os.getenv("REDIS_SSL_KEYFILE"),
+        # Connection settings
+        socket_timeout=float(os.getenv("REDIS_SOCKET_TIMEOUT", "5.0")),
+        socket_connect_timeout=float(os.getenv("REDIS_SOCKET_CONNECT_TIMEOUT", "5.0")),
+        max_connections=int(os.getenv("REDIS_MAX_CONNECTIONS", "10")),
+        # Retry settings
+        retry_on_timeout=os.getenv("REDIS_RETRY_ON_TIMEOUT", "true").lower() == "true",
+        retry_max_attempts=int(os.getenv("REDIS_RETRY_MAX_ATTEMPTS", "3")),
+        retry_base_delay=float(os.getenv("REDIS_RETRY_BASE_DELAY", "0.1")),
+        retry_max_delay=float(os.getenv("REDIS_RETRY_MAX_DELAY", "2.0")),
+    )
+
+
+def get_redis_config_dict() -> dict:
+    """Get Redis configuration as a dictionary (legacy compatibility).
 
-    # Fall back to individual env vars
+    Returns:
+        Dict with connection parameters
+
+    """
+    config = get_redis_config()
     return {
-        "host": os.getenv("REDIS_HOST", "localhost"),
-        "port": int(os.getenv("REDIS_PORT", "6379")),
-        "password": os.getenv("REDIS_PASSWORD"),
-        "db": int(os.getenv("REDIS_DB", "0")),
-        "use_mock": False,
+        "host": config.host,
+        "port": config.port,
+        "password": config.password,
+        "db": config.db,
+        "use_mock": config.use_mock,
+        "ssl": config.ssl,
     }
 
 
 def get_redis_memory(
     url: str | None = None,
     use_mock: bool | None = None,
+    config: RedisConfig | None = None,
 ) -> RedisShortTermMemory:
-    """
-    Create a RedisShortTermMemory instance with environment-based config.
+    """Create a RedisShortTermMemory instance with environment-based config.
 
     Args:
         url: Optional explicit Redis URL (overrides env vars)
         use_mock: Optional explicit mock mode (overrides env vars)
+        config: Optional explicit RedisConfig (overrides all other options)
 
     Returns:
         Configured RedisShortTermMemory instance
@@ -105,45 +184,51 @@ def get_redis_memory(
         # Auto-configure from environment
         memory = get_redis_memory()
 
-        # Explicit URL
-        memory = get_redis_memory(url="redis://localhost:6379")
+        # Explicit URL (SSL auto-detected from rediss://)
+        memory = get_redis_memory(url="rediss://user:pass@managed-redis.com:6379")
 
         # Force mock mode
         memory = get_redis_memory(use_mock=True)
+
+        # Explicit config with all options
+        from empathy_os.memory.short_term import RedisConfig
+        config = RedisConfig(
+            host="redis.example.com",
+            port=6379,
+            ssl=True,
+            retry_max_attempts=5,
+        )
+        memory = get_redis_memory(config=config)
+
     """
+    # Explicit config takes highest priority
+    if config is not None:
+        return RedisShortTermMemory(config=config)
+
     # Explicit mock mode
     if use_mock is True:
         return RedisShortTermMemory(use_mock=True)
 
     # Explicit URL
     if url:
-        config = parse_redis_url(url)
-        return RedisShortTermMemory(
-            host=config["host"],
-            port=config["port"],
-            password=config["password"],
-            db=config["db"],
+        url_config = parse_redis_url(url)
+        redis_config = RedisConfig(
+            host=url_config["host"],
+            port=url_config["port"],
+            password=url_config["password"],
+            db=url_config["db"],
+            ssl=url_config.get("ssl", False),
             use_mock=False,
         )
+        return RedisShortTermMemory(config=redis_config)
 
     # Environment-based config
-    config = get_redis_config()
-
-    if config.get("use_mock"):
-        return RedisShortTermMemory(use_mock=True)
-
-    return RedisShortTermMemory(
-        host=config["host"],
-        port=config["port"],
-        password=config.get("password"),
-        db=config.get("db", 0),
-        use_mock=False,
-    )
+    env_config = get_redis_config()
+    return RedisShortTermMemory(config=env_config)
 
 
 def check_redis_connection() -> dict:
-    """
-    Check Redis connection and return status.
+    """Check Redis connection and return status.
 
     Returns:
         Dict with connection status and info
@@ -152,16 +237,17 @@ def check_redis_connection() -> dict:
         >>> status = check_redis_connection()
         >>> if status["connected"]:
         ...     print(f"Connected to {status['host']}:{status['port']}")
+
     """
     config = get_redis_config()
 
     result = {
         "config_source": "environment",
-        "use_mock": config.get("use_mock", False),
-        "host": config.get("host"),
-        "port": config.get("port"),
-        "has_password": bool(config.get("password")),
-        "db": config.get("db", 0),
+        "use_mock": config.use_mock,
+        "host": config.host,
+        "port": config.port,
+        "has_password": bool(config.password),
+        "db": config.db,
         "connected": False,
         "error": None,
     }
@@ -194,8 +280,7 @@ def check_redis_connection() -> dict:
 
 # Convenience function for Railway deployments
 def get_railway_redis() -> RedisShortTermMemory:
-    """
-    Get Redis configured for Railway deployment.
+    """Get Redis configured for Railway deployment.
 
     Railway automatically sets REDIS_URL when you add a Redis service.
 
@@ -204,13 +289,14 @@ def get_railway_redis() -> RedisShortTermMemory:
 
     Raises:
         EnvironmentError: If REDIS_URL is not set
+
     """
     redis_url = os.getenv("REDIS_URL") or os.getenv("REDIS_PRIVATE_URL")
 
     if not redis_url:
         raise OSError(
             "REDIS_URL not found. Make sure Redis is added to your Railway project.\n"
-            "Run: railway add --database redis"
+            "Run: railway add --database redis",
         )
 
     return get_redis_memory(url=redis_url)