chore: remove Redis dependency, add 80% coverage threshold

- Replace Redis cache with in-memory cache
- Remove redis from dependencies
- Add --cov-fail-under=80 to CI tests

Author: nolancacheux

.github/workflows/ci.yml

@@ -53,10 +53,10 @@ jobs:
           uv venv
           uv pip install -e ".[dev]"
 
-      - name: Run tests
+      - name: Run tests with coverage
         run: |
           source .venv/bin/activate
-          pytest tests/ -v --cov=src --cov-report=xml --cov-report=term-missing
+          pytest tests/ -v --cov=src --cov-report=xml --cov-report=term-missing --cov-fail-under=80
         env:
           GROQ_API_KEY: "test-key-for-ci"
 

Dockerfile.api

@@ -29,7 +29,6 @@ RUN pip install --no-cache-dir \
     "uvicorn[standard]>=0.30.0" \
     pydantic>=2.7.0 \
     pydantic-settings>=2.3.0 \
-    redis>=5.0.0 \
     slowapi>=0.1.9 \
     httpx>=0.27.0 \
     tenacity>=8.4.0 \

pyproject.toml

@@ -41,8 +41,7 @@ dependencies = [
     "pydantic>=2.7.0",
     "pydantic-settings>=2.3.0",
 
-    # Caching & Rate Limiting
-    "redis>=5.0.0",
+    # Rate Limiting
     "slowapi>=0.1.9",
 
     # Utilities

src/config/settings.py

@@ -63,8 +63,7 @@ def validate_llm_config(self) -> "Settings":
     qdrant_api_key: SecretStr | None = None
     qdrant_collection: str = "sec_filings"
 
-    # Redis
-    redis_url: str = "redis://localhost:6379"
+    # Cache
     cache_ttl_seconds: int = 3600  # 1 hour default
 
     # Companies House (UK)

src/utils/cache.py

@@ -1,53 +1,29 @@
-"""Redis caching utilities for API responses."""
+"""In-memory caching utilities for API responses."""
 
 import hashlib
 import json
+import time
 from functools import lru_cache
 from typing import Any
 
-import redis
 import structlog
 
 from src.config import get_settings
 
 logger = structlog.get_logger()
 
 
-class RedisCache:
-    """Redis-based caching for API responses."""
+class MemoryCache:
+    """Simple in-memory caching for API responses."""
 
-    def __init__(self, url: str, default_ttl: int = 3600) -> None:
-        """Initialize Redis cache.
+    def __init__(self, default_ttl: int = 3600) -> None:
+        """Initialize memory cache.
 
         Args:
-            url: Redis connection URL
             default_ttl: Default TTL in seconds
         """
-        self._client: redis.Redis | None = None
-        self._url = url
+        self._cache: dict[str, tuple[Any, float]] = {}
         self._default_ttl = default_ttl
-        self._connected = False
-
-    def _connect(self) -> redis.Redis | None:
-        """Establish Redis connection with error handling."""
-        if self._client is not None:
-            return self._client
-
-        try:
-            self._client = redis.from_url(
-                self._url,
-                decode_responses=True,
-                socket_connect_timeout=5,
-            )
-            # Test connection
-            self._client.ping()
-            self._connected = True
-            logger.info("redis_connected", url=self._url)
-            return self._client
-        except redis.ConnectionError as e:
-            logger.warning("redis_connection_failed", error=str(e))
-            self._connected = False
-            return None
 
     @staticmethod
     def _make_key(prefix: str, *args: Any, **kwargs: Any) -> str:
@@ -56,53 +32,51 @@ def _make_key(prefix: str, *args: Any, **kwargs: Any) -> str:
         key_hash = hashlib.sha256(key_data.encode()).hexdigest()[:16]
         return f"{prefix}:{key_hash}"
 
+    def _cleanup_expired(self) -> None:
+        """Remove expired entries from cache."""
+        now = time.time()
+        expired = [k for k, (_, exp) in self._cache.items() if exp < now]
+        for key in expired:
+            del self._cache[key]
+
     def get(self, key: str) -> Any | None:
         """Get value from cache.
 
         Args:
             key: Cache key
 
         Returns:
-            Cached value or None if not found
+            Cached value or None if not found or expired
         """
-        client = self._connect()
-        if client is None:
-            return None
+        self._cleanup_expired()
 
-        try:
-            value = client.get(key)
-            if value:
+        if key in self._cache:
+            value, expiry = self._cache[key]
+            if expiry > time.time():
                 logger.debug("cache_hit", key=key)
-                return json.loads(value)
-            logger.debug("cache_miss", key=key)
-            return None
-        except (redis.RedisError, json.JSONDecodeError) as e:
-            logger.warning("cache_get_error", key=key, error=str(e))
-            return None
+                return value
+            else:
+                del self._cache[key]
+
+        logger.debug("cache_miss", key=key)
+        return None
 
     def set(self, key: str, value: Any, ttl: int | None = None) -> bool:
         """Set value in cache.
 
         Args:
             key: Cache key
-            value: Value to cache (must be JSON serializable)
+            value: Value to cache
             ttl: Time to live in seconds (uses default if not specified)
 
         Returns:
-            True if successful, False otherwise
+            True if successful
         """
-        client = self._connect()
-        if client is None:
-            return False
-
-        try:
-            ttl = ttl or self._default_ttl
-            client.setex(key, ttl, json.dumps(value))
-            logger.debug("cache_set", key=key, ttl=ttl)
-            return True
-        except (redis.RedisError, TypeError) as e:
-            logger.warning("cache_set_error", key=key, error=str(e))
-            return False
+        ttl = ttl or self._default_ttl
+        expiry = time.time() + ttl
+        self._cache[key] = (value, expiry)
+        logger.debug("cache_set", key=key, ttl=ttl)
+        return True
 
     def delete(self, key: str) -> bool:
         """Delete value from cache.
@@ -111,31 +85,26 @@ def delete(self, key: str) -> bool:
             key: Cache key
 
         Returns:
-            True if deleted, False otherwise
+            True if deleted, False if not found
         """
-        client = self._connect()
-        if client is None:
-            return False
-
-        try:
-            client.delete(key)
+        if key in self._cache:
+            del self._cache[key]
             logger.debug("cache_delete", key=key)
             return True
-        except redis.RedisError as e:
-            logger.warning("cache_delete_error", key=key, error=str(e))
-            return False
+        return False
 
     @property
     def is_connected(self) -> bool:
-        """Check if Redis is connected."""
-        return self._connected
+        """Always connected for memory cache."""
+        return True
+
+
+# Backwards compatibility aliases
+RedisCache = MemoryCache
 
 
 @lru_cache
-def get_cache() -> RedisCache:
-    """Get cached Redis cache instance."""
+def get_cache() -> MemoryCache:
+    """Get cached memory cache instance."""
     settings = get_settings()
-    return RedisCache(
-        url=settings.redis_url,
-        default_ttl=settings.cache_ttl_seconds,
-    )
+    return MemoryCache(default_ttl=settings.cache_ttl_seconds)