auto-coder 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/common/todos/cache/base_cache.py

@@ -0,0 +1,89 @@
+"""
+Base cache interface for todo caching.
+
+This module defines the abstract base class for all cache implementations,
+providing a consistent interface for caching operations.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, Any, List
+
+
+class BaseCache(ABC):
+    """Abstract base class for cache implementations."""
+    
+    @abstractmethod
+    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
+        """
+        pass
+    
+    @abstractmethod
+    def set(self, key: str, value: Any, ttl: Optional[float] = None) -> 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
+        """
+        pass
+    
+    @abstractmethod
+    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
+        """
+        pass
+    
+    @abstractmethod
+    def clear(self) -> None:
+        """Clear all items from the cache."""
+        pass
+    
+    @abstractmethod
+    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
+        """
+        pass
+    
+    @abstractmethod
+    def size(self) -> int:
+        """
+        Get the current number of items in the cache.
+        
+        Returns:
+            The number of items currently in the cache
+        """
+        pass
+    
+    @abstractmethod
+    def keys(self) -> List[str]:
+        """
+        Get all keys currently in the cache.
+        
+        Returns:
+            List of keys currently in the cache
+        """
+        pass 

autocoder/common/todos/cache/cache_manager.py

@@ -0,0 +1,228 @@
+"""
+Cache manager for todo caching.
+
+This module provides a high-level interface for managing caches of
+todo lists, with support for cache warming, invalidation,
+and statistics reporting.
+"""
+
+import logging
+from typing import Optional, List, Dict, Any
+
+from .base_cache import BaseCache
+from .memory_cache import MemoryCache
+from ..models import TodoList
+
+logger = logging.getLogger(__name__)
+
+
+class CacheManager:
+    """High-level cache manager for todo lists."""
+    
+    def __init__(self, todo_cache: Optional[BaseCache] = None):
+        """
+        Initialize cache manager.
+        
+        Args:
+            todo_cache: Cache instance for todo lists
+        """
+        self.todo_cache = todo_cache or MemoryCache(
+            max_size=50, default_ttl=300.0  # 5 minutes default
+        )
+        
+        # Ensure cache implements required interface
+        self._validate_cache_interface(self.todo_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_todo_list_key(self, conversation_id: str) -> str:
+        """Generate cache key for todo list."""
+        return f"todos:{conversation_id}"
+    
+    def cache_todo_list(
+        self, 
+        todo_list: Dict[str, Any],
+        ttl: Optional[float] = None
+    ) -> None:
+        """
+        Cache a todo list.
+        
+        Args:
+            todo_list: The todo list to cache
+            ttl: Time to live in seconds, None for default
+        """
+        try:
+            conversation_id = todo_list.get('conversation_id')
+            if not conversation_id:
+                logger.error("Cannot cache todo list without conversation_id")
+                return
+                
+            key = self._get_todo_list_key(conversation_id)
+            self.todo_cache.set(key, todo_list, ttl=ttl)
+            logger.debug(f"Cached todo list for conversation {conversation_id}")
+        except Exception as e:
+            logger.error(f"Failed to cache todo list for conversation {conversation_id}: {e}")
+    
+    def get_todo_list(self, conversation_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get a todo list from cache.
+        
+        Args:
+            conversation_id: The conversation ID
+            
+        Returns:
+            The cached todo list or None if not found
+        """
+        try:
+            key = self._get_todo_list_key(conversation_id)
+            todo_list = self.todo_cache.get(key)
+            if todo_list:
+                logger.debug(f"Cache hit for todo list of conversation {conversation_id}")
+            else:
+                logger.debug(f"Cache miss for todo list of conversation {conversation_id}")
+            return todo_list
+        except Exception as e:
+            logger.error(f"Failed to get todo list for conversation {conversation_id} from cache: {e}")
+            return None
+    
+    def invalidate_todo_list(self, conversation_id: str) -> bool:
+        """
+        Invalidate cached todo list.
+        
+        Args:
+            conversation_id: The conversation ID
+            
+        Returns:
+            True if todo list was cached and removed, False otherwise
+        """
+        try:
+            key = self._get_todo_list_key(conversation_id)
+            result = self.todo_cache.delete(key)
+            if result:
+                logger.debug(f"Invalidated todo list for conversation {conversation_id}")
+            return result
+        except Exception as e:
+            logger.error(f"Failed to invalidate todo list for conversation {conversation_id}: {e}")
+            return False
+    
+    def cache_todo_lists(
+        self, 
+        todo_lists: List[Dict[str, Any]],
+        ttl: Optional[float] = None
+    ) -> int:
+        """
+        Cache multiple todo lists.
+        
+        Args:
+            todo_lists: List of todo lists to cache
+            ttl: Time to live in seconds, None for default
+            
+        Returns:
+            Number of todo lists successfully cached
+        """
+        count = 0
+        for todo_list in todo_lists:
+            try:
+                self.cache_todo_list(todo_list, ttl=ttl)
+                count += 1
+            except Exception as e:
+                conversation_id = todo_list.get('conversation_id', 'unknown')
+                logger.error(f"Failed to cache todo list for conversation {conversation_id}: {e}")
+        
+        return count
+    
+    def invalidate_todo_lists(self, conversation_ids: List[str]) -> Dict[str, bool]:
+        """
+        Invalidate multiple todo lists.
+        
+        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_todo_list(conversation_id)
+        
+        return results
+    
+    def clear_all_caches(self) -> None:
+        """Clear all caches."""
+        try:
+            self.todo_cache.clear()
+            logger.info("Cleared all todo 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 = {
+                "todo_cache": {
+                    "size": self.todo_cache.size(),
+                    "max_size": getattr(self.todo_cache, 'max_size', 'unknown')
+                }
+            }
+            
+            # Add detailed stats if available
+            if hasattr(self.todo_cache, 'get_statistics'):
+                get_stats_method = getattr(self.todo_cache, 'get_statistics')
+                stats["todo_cache"].update(
+                    get_stats_method()
+                )
+            
+            return stats
+            
+        except Exception as e:
+            logger.error(f"Failed to get cache statistics: {e}")
+            return {
+                "todo_cache": {"size": 0, "max_size": "unknown"},
+                "error": str(e)
+            }
+    
+    def is_todo_list_cached(self, conversation_id: str) -> bool:
+        """
+        Check if a todo list is cached.
+        
+        Args:
+            conversation_id: The conversation ID
+            
+        Returns:
+            True if todo list is cached, False otherwise
+        """
+        try:
+            key = self._get_todo_list_key(conversation_id)
+            return self.todo_cache.exists(key)
+        except Exception as e:
+            logger.error(f"Failed to check if todo list for conversation {conversation_id} is 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.todo_cache.keys()
+            # Extract conversation IDs from cache keys
+            conversation_ids = []
+            for key in keys:
+                if key.startswith("todos:"):
+                    conversation_ids.append(key[6:])  # Remove "todos:" prefix
+            return conversation_ids
+        except Exception as e:
+            logger.error(f"Failed to get cached conversation IDs: {e}")
+            return [] 

autocoder/common/todos/cache/memory_cache.py

@@ -0,0 +1,225 @@
+"""
+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 = 50, 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 = _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
+            } 

autocoder/common/todos/config.py

@@ -0,0 +1,155 @@
+"""
+Todo manager configuration class.
+"""
+
+import os
+import json
+from dataclasses import dataclass
+from typing import Optional, Dict, Any
+
+
+@dataclass
+class TodoManagerConfig:
+    """Configuration class for todo manager"""
+    
+    storage_path: str = "./.auto-coder/todos"
+    max_cache_size: int = 50
+    cache_ttl: float = 300.0
+    enable_compression: bool = False
+    log_level: str = "INFO"
+    
+    def __post_init__(self):
+        """Validate configuration"""
+        self._validate()
+    
+    def _validate(self):
+        """Validate configuration data"""
+        # Validate storage path
+        if not self.storage_path or not isinstance(self.storage_path, str):
+            raise ValueError("Storage path cannot be empty")
+        
+        # Validate cache size
+        if not isinstance(self.max_cache_size, int) or self.max_cache_size <= 0:
+            raise ValueError("Cache size must be a positive integer")
+        
+        # Validate cache TTL
+        if not isinstance(self.cache_ttl, (int, float)) or self.cache_ttl <= 0:
+            raise ValueError("Cache TTL must be a positive number")
+        
+        # Validate log level
+        valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+        if self.log_level not in valid_levels:
+            raise ValueError(f"Invalid log level: {self.log_level}, valid levels: {valid_levels}")
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return {
+            "storage_path": self.storage_path,
+            "max_cache_size": self.max_cache_size,
+            "cache_ttl": self.cache_ttl,
+            "enable_compression": self.enable_compression,
+            "log_level": self.log_level
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "TodoManagerConfig":
+        """Create config from dictionary"""
+        config = cls()
+        
+        for key, value in data.items():
+            if hasattr(config, key):
+                setattr(config, key, value)
+        
+        config._validate()
+        return config
+    
+    @classmethod
+    def from_env(cls, prefix: str = "TODO_") -> "TodoManagerConfig":
+        """Create config from environment variables"""
+        config = cls()
+        
+        env_mapping = {
+            f"{prefix}STORAGE_PATH": "storage_path",
+            f"{prefix}MAX_CACHE_SIZE": "max_cache_size",
+            f"{prefix}CACHE_TTL": "cache_ttl",
+            f"{prefix}ENABLE_COMPRESSION": "enable_compression",
+            f"{prefix}LOG_LEVEL": "log_level"
+        }
+        
+        for env_key, attr_name in env_mapping.items():
+            env_value = os.environ.get(env_key)
+            if env_value is not None:
+                try:
+                    if attr_name in ["max_cache_size"]:
+                        value = int(env_value)
+                    elif attr_name in ["cache_ttl"]:
+                        value = float(env_value)
+                    elif attr_name in ["enable_compression"]:
+                        value = env_value.lower() in ["true", "1", "yes", "on"]
+                    else:
+                        value = env_value
+                    
+                    setattr(config, attr_name, value)
+                except (ValueError, TypeError) as e:
+                    raise ValueError(f"Environment variable {env_key} has invalid value '{env_value}': {e}")
+        
+        config._validate()
+        return config
+    
+    def save_to_file(self, file_path: str):
+        """Save config to file"""
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(self.to_dict(), f, indent=2, ensure_ascii=False)
+    
+    @classmethod
+    def load_from_file(cls, file_path: str) -> "TodoManagerConfig":
+        """Load config from file"""
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"Config file not found: {file_path}")
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            return cls.from_dict(data)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Config file format error: {e}")
+    
+    def copy(self) -> "TodoManagerConfig":
+        """Create a deep copy of the config"""
+        return TodoManagerConfig.from_dict(self.to_dict())
+    
+    def update(self, **kwargs):
+        """Update config fields"""
+        backup_values = {}
+        for key in kwargs.keys():
+            if hasattr(self, key):
+                backup_values[key] = getattr(self, key)
+            else:
+                raise AttributeError(f"Config has no attribute: {key}")
+        
+        try:
+            for key, value in kwargs.items():
+                setattr(self, key, value)
+            self._validate()
+        except Exception:
+            for key, value in backup_values.items():
+                setattr(self, key, value)
+            raise
+    
+    def __repr__(self) -> str:
+        """String representation"""
+        return (f"TodoManagerConfig("
+                f"storage_path='{self.storage_path}', "
+                f"max_cache_size={self.max_cache_size}, "
+                f"cache_ttl={self.cache_ttl}, "
+                f"log_level='{self.log_level}')")
+    
+    def __eq__(self, other) -> bool:
+        """Equality comparison"""
+        if not isinstance(other, TodoManagerConfig):
+            return False
+        
+        return self.to_dict() == other.to_dict()