cache.py

"""Caching layer:
Attempts to use Redis when `REDIS_URL` environment variable is set and the `redis`
package is installed. Falls back to a thread-safe in-memory cache when Redis is
unavailable. The interface mirrors the previous SimpleCache: `set`, `get`, `clear`.
"""

import os
import threading
import time

try:
    import redis
except Exception:
    redis = None


class SimpleCache:
    def __init__(self):
        self._store = {}
        self._lock = threading.Lock()

    def set(self, key, value, ttl=300):
        expire = time.time() + ttl
        with self._lock:
            self._store[key] = (value, expire)

    def get(self, key):
        with self._lock:
            v = self._store.get(key)
            if not v:
                return None
            value, expire = v
            if expire < time.time():
                # expired
                del self._store[key]
                return None
            return value

    def clear(self):
        with self._lock:
            self._store.clear()


class RedisCache:
    def __init__(self, url=None, prefix='es:'):
        if not redis:
            raise RuntimeError('redis package is not available')
        self.prefix = prefix
        self.client = redis.from_url(url or os.environ.get('REDIS_URL'), decode_responses=True)
        # Ensure connection works (raises if not)
        self.client.ping()

    def _key(self, key):
        return f"{self.prefix}{key}"

    def set(self, key, value, ttl=300):
        self.client.set(self._key(key), value, ex=ttl)

    def get(self, key):
        return self.client.get(self._key(key))

    def clear(self):
        # Remove keys matching prefix
        pattern = f"{self.prefix}*"
        for k in self.client.scan_iter(match=pattern):
            self.client.delete(k)


# Choose backend: RedisCache if REDIS_URL is set and redis is available, else SimpleCache
_cache = None
try:
    redis_url = os.environ.get('REDIS_URL')
    if redis and redis_url:
        try:
            _cache = RedisCache(redis_url)
        except Exception:
            # Fall back to in-memory cache if Redis is unreachable
            _cache = SimpleCache()
    else:
        _cache = SimpleCache()
except Exception:
    _cache = SimpleCache()

cache = _cache