auto-coder 0.1.397__py3-none-any.whl → 0.1.398__py3-none-any.whl

autocoder/common/conversations/cache/cache_manager.py

@@ -0,0 +1,368 @@
+"""
+Cache manager for conversation and message caching.
+
+This module provides a high-level interface for managing caches of
+conversations and messages, with support for cache warming, invalidation,
+and statistics reporting.
+"""
+
+import logging
+from typing import Optional, List, Dict, Any, Callable
+
+from .base_cache import BaseCache
+from .memory_cache import MemoryCache
+from ..models import Conversation, ConversationMessage
+
+logger = logging.getLogger(__name__)
+
+
+class CacheManager:
+    """High-level cache manager for conversations and messages."""
+    
+    def __init__(
+        self,
+        conversation_cache: Optional[BaseCache] = None,
+        message_cache: Optional[BaseCache] = None
+    ):
+        """
+        Initialize cache manager.
+        
+        Args:
+            conversation_cache: Cache instance for conversations
+            message_cache: Cache instance for messages
+        """
+        self.conversation_cache = conversation_cache or MemoryCache(
+            max_size=100, default_ttl=600.0  # 10 minutes default
+        )
+        self.message_cache = message_cache or MemoryCache(
+            max_size=500, default_ttl=300.0  # 5 minutes default  
+        )
+        
+        # Ensure caches implement required interface
+        self._validate_cache_interface(self.conversation_cache)
+        self._validate_cache_interface(self.message_cache)
+    
+    def _validate_cache_interface(self, cache: BaseCache) -> None:
+        """Validate that cache implements required interface."""
+        required_methods = ['get', 'set', 'delete', 'clear', 'exists', 'size', 'keys']
+        for method in required_methods:
+            if not hasattr(cache, method) or not callable(getattr(cache, method)):
+                raise TypeError(f"Cache must implement {method} method")
+    
+    def _get_conversation_key(self, conversation_id: str) -> str:
+        """Generate cache key for conversation."""
+        return f"conv:{conversation_id}"
+    
+    def _get_messages_key(self, conversation_id: str) -> str:
+        """Generate cache key for conversation messages."""
+        return f"msgs:{conversation_id}"
+    
+    def cache_conversation(
+        self, 
+        conversation: Conversation,
+        ttl: Optional[float] = None
+    ) -> None:
+        """
+        Cache a conversation.
+        
+        Args:
+            conversation: The conversation to cache
+            ttl: Time to live in seconds, None for default
+        """
+        try:
+            key = self._get_conversation_key(conversation.conversation_id)
+            self.conversation_cache.set(key, conversation, ttl=ttl)
+            logger.debug(f"Cached conversation {conversation.conversation_id}")
+        except Exception as e:
+            logger.error(f"Failed to cache conversation {conversation.conversation_id}: {e}")
+    
+    def get_conversation(self, conversation_id: str) -> Optional[Conversation]:
+        """
+        Get a conversation from cache.
+        
+        Args:
+            conversation_id: The conversation ID
+            
+        Returns:
+            The cached conversation or None if not found
+        """
+        try:
+            key = self._get_conversation_key(conversation_id)
+            conversation = self.conversation_cache.get(key)
+            if conversation:
+                logger.debug(f"Cache hit for conversation {conversation_id}")
+            else:
+                logger.debug(f"Cache miss for conversation {conversation_id}")
+            return conversation
+        except Exception as e:
+            logger.error(f"Failed to get conversation {conversation_id} from cache: {e}")
+            return None
+    
+    def cache_messages(
+        self,
+        conversation_id: str,
+        messages: List[ConversationMessage],
+        ttl: Optional[float] = None
+    ) -> None:
+        """
+        Cache messages for a conversation.
+        
+        Args:
+            conversation_id: The conversation ID
+            messages: List of messages to cache
+            ttl: Time to live in seconds, None for default
+        """
+        try:
+            key = self._get_messages_key(conversation_id)
+            self.message_cache.set(key, messages, ttl=ttl)
+            logger.debug(f"Cached {len(messages)} messages for conversation {conversation_id}")
+        except Exception as e:
+            logger.error(f"Failed to cache messages for conversation {conversation_id}: {e}")
+    
+    def get_messages(self, conversation_id: str) -> Optional[List[ConversationMessage]]:
+        """
+        Get messages from cache.
+        
+        Args:
+            conversation_id: The conversation ID
+            
+        Returns:
+            List of cached messages or None if not found
+        """
+        try:
+            key = self._get_messages_key(conversation_id) 
+            messages = self.message_cache.get(key)
+            if messages:
+                logger.debug(f"Cache hit for messages of conversation {conversation_id}")
+            else:
+                logger.debug(f"Cache miss for messages of conversation {conversation_id}")
+            return messages
+        except Exception as e:
+            logger.error(f"Failed to get messages for conversation {conversation_id} from cache: {e}")
+            return None
+    
+    def invalidate_conversation(self, conversation_id: str) -> bool:
+        """
+        Invalidate cached conversation.
+        
+        Args:
+            conversation_id: The conversation ID
+            
+        Returns:
+            True if conversation was cached and removed, False otherwise
+        """
+        try:
+            key = self._get_conversation_key(conversation_id)
+            result = self.conversation_cache.delete(key)
+            if result:
+                logger.debug(f"Invalidated conversation {conversation_id}")
+            return result
+        except Exception as e:
+            logger.error(f"Failed to invalidate conversation {conversation_id}: {e}")
+            return False
+    
+    def invalidate_messages(self, conversation_id: str) -> bool:
+        """
+        Invalidate cached messages.
+        
+        Args:
+            conversation_id: The conversation ID
+            
+        Returns:
+            True if messages were cached and removed, False otherwise
+        """
+        try:
+            key = self._get_messages_key(conversation_id)
+            result = self.message_cache.delete(key)
+            if result:
+                logger.debug(f"Invalidated messages for conversation {conversation_id}")
+            return result
+        except Exception as e:
+            logger.error(f"Failed to invalidate messages for conversation {conversation_id}: {e}")
+            return False
+    
+    def invalidate_all(self, conversation_id: str) -> Dict[str, bool]:
+        """
+        Invalidate all cached data for a conversation.
+        
+        Args:
+            conversation_id: The conversation ID
+            
+        Returns:
+            Dictionary with invalidation results
+        """
+        return {
+            "conversation": self.invalidate_conversation(conversation_id),
+            "messages": self.invalidate_messages(conversation_id)
+        }
+    
+    def warm_conversation_cache(
+        self, 
+        data_loader: Callable[[], List[Conversation]]
+    ) -> int:
+        """
+        Warm conversation cache with data.
+        
+        Args:
+            data_loader: Function that returns conversations to cache
+            
+        Returns:
+            Number of conversations cached
+        """
+        try:
+            conversations = data_loader()
+            count = 0
+            
+            for conversation in conversations:
+                self.cache_conversation(conversation)
+                count += 1
+            
+            logger.info(f"Warmed conversation cache with {count} conversations")
+            return count
+            
+        except Exception as e:
+            logger.error(f"Failed to warm conversation cache: {e}")
+            return 0
+    
+    def cache_conversations(
+        self, 
+        conversations: List[Conversation],
+        ttl: Optional[float] = None
+    ) -> int:
+        """
+        Cache multiple conversations.
+        
+        Args:
+            conversations: List of conversations to cache
+            ttl: Time to live in seconds, None for default
+            
+        Returns:
+            Number of conversations successfully cached
+        """
+        count = 0
+        for conversation in conversations:
+            try:
+                self.cache_conversation(conversation, ttl=ttl)
+                count += 1
+            except Exception as e:
+                logger.error(f"Failed to cache conversation {conversation.conversation_id}: {e}")
+        
+        return count
+    
+    def invalidate_conversations(self, conversation_ids: List[str]) -> Dict[str, bool]:
+        """
+        Invalidate multiple conversations.
+        
+        Args:
+            conversation_ids: List of conversation IDs to invalidate
+            
+        Returns:
+            Dictionary mapping conversation IDs to invalidation results
+        """
+        results = {}
+        for conversation_id in conversation_ids:
+            results[conversation_id] = self.invalidate_conversation(conversation_id)
+        
+        return results
+    
+    def clear_all_caches(self) -> None:
+        """Clear all caches."""
+        try:
+            self.conversation_cache.clear()
+            self.message_cache.clear()
+            logger.info("Cleared all caches")
+        except Exception as e:
+            logger.error(f"Failed to clear caches: {e}")
+    
+    def get_cache_statistics(self) -> Dict[str, Any]:
+        """
+        Get statistics for all caches.
+        
+        Returns:
+            Dictionary with cache statistics
+        """
+        try:
+            stats = {
+                "conversation_cache": {
+                    "size": self.conversation_cache.size(),
+                    "max_size": getattr(self.conversation_cache, 'max_size', 'unknown')
+                },
+                "message_cache": {
+                    "size": self.message_cache.size(),
+                    "max_size": getattr(self.message_cache, 'max_size', 'unknown')
+                }
+            }
+            
+            # Add detailed stats if available
+            if hasattr(self.conversation_cache, 'get_statistics'):
+                stats["conversation_cache"].update(
+                    self.conversation_cache.get_statistics()
+                )
+            
+            if hasattr(self.message_cache, 'get_statistics'):
+                stats["message_cache"].update(
+                    self.message_cache.get_statistics()
+                )
+            
+            return stats
+            
+        except Exception as e:
+            logger.error(f"Failed to get cache statistics: {e}")
+            return {
+                "conversation_cache": {"size": 0, "max_size": "unknown"},
+                "message_cache": {"size": 0, "max_size": "unknown"},
+                "error": str(e)
+            }
+    
+    def is_conversation_cached(self, conversation_id: str) -> bool:
+        """
+        Check if a conversation is cached.
+        
+        Args:
+            conversation_id: The conversation ID
+            
+        Returns:
+            True if conversation is cached, False otherwise
+        """
+        try:
+            key = self._get_conversation_key(conversation_id)
+            return self.conversation_cache.exists(key)
+        except Exception as e:
+            logger.error(f"Failed to check if conversation {conversation_id} is cached: {e}")
+            return False
+    
+    def is_messages_cached(self, conversation_id: str) -> bool:
+        """
+        Check if messages are cached.
+        
+        Args:
+            conversation_id: The conversation ID
+            
+        Returns:
+            True if messages are cached, False otherwise
+        """
+        try:
+            key = self._get_messages_key(conversation_id)
+            return self.message_cache.exists(key)
+        except Exception as e:
+            logger.error(f"Failed to check if messages for conversation {conversation_id} are cached: {e}")
+            return False
+    
+    def get_cached_conversation_ids(self) -> List[str]:
+        """
+        Get all cached conversation IDs.
+        
+        Returns:
+            List of conversation IDs currently cached
+        """
+        try:
+            keys = self.conversation_cache.keys()
+            # Extract conversation IDs from cache keys
+            conversation_ids = []
+            for key in keys:
+                if key.startswith("conv:"):
+                    conversation_ids.append(key[5:])  # Remove "conv:" prefix
+            return conversation_ids
+        except Exception as e:
+            logger.error(f"Failed to get cached conversation IDs: {e}")
+            return [] 

autocoder/common/conversations/cache/memory_cache.py

@@ -0,0 +1,224 @@
+"""
+Memory-based cache implementation with LRU eviction and TTL support.
+
+This module provides a thread-safe in-memory cache with configurable
+size limits, TTL expiration, and LRU eviction policies.
+"""
+
+import time
+import threading
+from collections import OrderedDict
+from typing import Optional, Any, List, Dict
+from dataclasses import dataclass
+
+from .base_cache import BaseCache
+
+# Sentinel object to distinguish between "no ttl provided" and "ttl=None"
+_TTL_NOT_PROVIDED = object()
+
+@dataclass
+class CacheEntry:
+    """Cache entry with value and expiration time."""
+    value: Any
+    expires_at: Optional[float] = None
+    
+    def is_expired(self) -> bool:
+        """Check if this entry has expired."""
+        if self.expires_at is None:
+            return False
+        return time.time() > self.expires_at
+
+
+class MemoryCache(BaseCache):
+    """Thread-safe in-memory cache with LRU eviction and TTL support."""
+    
+    def __init__(self, max_size: int = 100, default_ttl: float = 300.0):
+        """
+        Initialize memory cache.
+        
+        Args:
+            max_size: Maximum number of items to cache
+            default_ttl: Default TTL in seconds for cached items
+        """
+        if max_size <= 0:
+            raise ValueError("max_size must be positive")
+        
+        self.max_size = max_size
+        self.default_ttl = default_ttl
+        self._cache: OrderedDict[str, CacheEntry] = OrderedDict()
+        self._lock = threading.RLock()
+        
+        # Optional statistics
+        self.hit_count = 0
+        self.miss_count = 0
+    
+    def get(self, key: str) -> Optional[Any]:
+        """
+        Get a value from the cache.
+        
+        Args:
+            key: The cache key
+            
+        Returns:
+            The cached value or None if not found/expired
+        """
+        with self._lock:
+            entry = self._cache.get(key)
+            
+            if entry is None:
+                self.miss_count += 1
+                return None
+            
+            if entry.is_expired():
+                # Remove expired entry
+                del self._cache[key]
+                self.miss_count += 1
+                return None
+            
+            # Move to end (most recently used)
+            self._cache.move_to_end(key)
+            self.hit_count += 1
+            return entry.value
+    
+    def set(self, key: str, value: Any, ttl: Optional[float] = _TTL_NOT_PROVIDED) -> None:
+        """
+        Set a value in the cache.
+        
+        Args:
+            key: The cache key
+            value: The value to cache
+            ttl: Time to live in seconds, None for no expiration
+        """
+        with self._lock:
+            # Calculate expiration time
+            expires_at = None
+            
+            if ttl is _TTL_NOT_PROVIDED:
+                # No ttl provided, use default_ttl behavior
+                if self.default_ttl > 0:
+                    expires_at = time.time() + self.default_ttl
+            elif ttl is None:
+                # Explicit None means permanent caching
+                expires_at = None
+            elif ttl > 0:
+                # Positive ttl value
+                expires_at = time.time() + ttl
+            # ttl <= 0 means permanent caching (expires_at stays None)
+            
+            # Create cache entry
+            entry = CacheEntry(value=value, expires_at=expires_at)
+            
+            # If key already exists, update it
+            if key in self._cache:
+                self._cache[key] = entry
+                self._cache.move_to_end(key)
+            else:
+                # Add new entry
+                self._cache[key] = entry
+                
+                # Evict oldest items if over capacity
+                while len(self._cache) > self.max_size:
+                    oldest_key = next(iter(self._cache))
+                    del self._cache[oldest_key]
+    
+    def delete(self, key: str) -> bool:
+        """
+        Delete a value from the cache.
+        
+        Args:
+            key: The cache key
+            
+        Returns:
+            True if the key was deleted, False if it didn't exist
+        """
+        with self._lock:
+            if key in self._cache:
+                del self._cache[key]
+                return True
+            return False
+    
+    def clear(self) -> None:
+        """Clear all items from the cache."""
+        with self._lock:
+            self._cache.clear()
+    
+    def exists(self, key: str) -> bool:
+        """
+        Check if a key exists in the cache.
+        
+        Args:
+            key: The cache key
+            
+        Returns:
+            True if the key exists and is not expired, False otherwise
+        """
+        with self._lock:
+            entry = self._cache.get(key)
+            
+            if entry is None:
+                return False
+            
+            if entry.is_expired():
+                # Remove expired entry
+                del self._cache[key]
+                return False
+            
+            return True
+    
+    def size(self) -> int:
+        """
+        Get the current number of items in the cache.
+        
+        Returns:
+            The number of items currently in the cache
+        """
+        with self._lock:
+            # Clean up expired items
+            self._cleanup_expired()
+            return len(self._cache)
+    
+    def keys(self) -> List[str]:
+        """
+        Get all keys currently in the cache.
+        
+        Returns:
+            List of keys currently in the cache
+        """
+        with self._lock:
+            # Clean up expired items
+            self._cleanup_expired()
+            return list(self._cache.keys())
+    
+    def _cleanup_expired(self) -> None:
+        """Remove all expired entries from the cache."""
+        current_time = time.time()
+        expired_keys = []
+        
+        for key, entry in self._cache.items():
+            if entry.expires_at is not None and current_time > entry.expires_at:
+                expired_keys.append(key)
+        
+        for key in expired_keys:
+            del self._cache[key]
+    
+    def get_statistics(self) -> Dict[str, Any]:
+        """
+        Get cache statistics.
+        
+        Returns:
+            Dictionary with cache statistics
+        """
+        with self._lock:
+            self._cleanup_expired()
+            
+            total_requests = self.hit_count + self.miss_count
+            hit_rate = self.hit_count / total_requests if total_requests > 0 else 0.0
+            
+            return {
+                "size": len(self._cache),
+                "max_size": self.max_size,
+                "hit_count": self.hit_count,
+                "miss_count": self.miss_count,
+                "hit_rate": hit_rate,
+                "default_ttl": self.default_ttl
+            }