completely remove persistence

Author: hazai

.vscode/settings.json

@@ -46,7 +46,7 @@
         "editor.defaultFormatter": "ms-python.black-formatter"
     },
     "python.envFile": "${workspaceFolder}/.venv",
-    "python.languageServer": "Pylance",
+    "python.languageServer": "None",
     "python.testing.pytestEnabled": true,
     "python.testing.pytestArgs": [
         "${workspaceFolder}/tests",
@@ -55,7 +55,6 @@
     "python.testing.unittestEnabled": false,
     //"python.envFile": "${workspaceFolder}/python_release.env",
 
-
     // MYPY
     "mypy-type-checker.args": [
         "--ignore-missing-imports",

nemoguardrails/cache/interface.py

@@ -18,10 +18,6 @@
 
 This module defines the abstract base class for cache implementations
 that can be used interchangeably throughout the guardrails system.
-
-Cache implementations may optionally support persistence by overriding
-the persist_now() method and supports_persistence() method. Persistence
-allows cache state to be saved to and loaded from external storage.
 """
 
 from abc import ABC, abstractmethod
@@ -121,31 +117,6 @@ def capacity(self) -> int:
         """
         pass
 
-    def persist_now(self) -> None:
-        """
-        Force immediate persistence of cache to storage.
-
-        This is an optional method that cache implementations can override
-        if they support persistence. The default implementation does nothing.
-
-        Implementations that support persistence should save the current
-        cache state to their configured storage backend.
-        """
-        # Default no-op implementation
-        pass
-
-    def supports_persistence(self) -> bool:
-        """
-        Check if this cache implementation supports persistence.
-
-        Returns:
-            True if the cache supports persistence, False otherwise.
-
-        The default implementation returns False. Cache implementations
-        that support persistence should override this to return True.
-        """
-        return False
-
     def get_stats(self) -> dict:
         """
         Get cache statistics.

nemoguardrails/cache/lfu.py

@@ -16,9 +16,7 @@
 """Least Frequently Used (LFU) cache implementation."""
 
 import asyncio
-import json
 import logging
-import os
 import threading
 import time
 from typing import Any, Callable, Optional
@@ -88,8 +86,6 @@ def __init__(
         self,
         capacity: int,
         track_stats: bool = False,
-        persistence_interval: Optional[float] = None,
-        persistence_path: Optional[str] = None,
         stats_logging_interval: Optional[float] = None,
     ) -> None:
         """
@@ -98,8 +94,6 @@ def __init__(
         Args:
             capacity: Maximum number of items the cache can hold
             track_stats: Enable tracking of cache statistics
-            persistence_interval: Seconds between periodic dumps to disk (None disables persistence)
-            persistence_path: Path to persistence file (defaults to 'lfu_cache.json' if persistence enabled)
             stats_logging_interval: Seconds between periodic stats logging (None disables logging)
         """
         if capacity < 0:
@@ -114,12 +108,6 @@ def __init__(
         self.freq_map: dict[int, DoublyLinkedList] = {}  # frequency -> list of nodes
         self.min_freq = 0  # Track minimum frequency for eviction
 
-        # Persistence configuration
-        self.persistence_interval = persistence_interval
-        self.persistence_path = persistence_path or "lfu_cache.json"
-        # Initialize to None to ensure first check doesn't trigger immediately
-        self.last_persist_time = None
-
         # Stats logging configuration
         self.stats_logging_interval = stats_logging_interval
         # Initialize to None to ensure first check doesn't trigger immediately
@@ -135,10 +123,6 @@ def __init__(
                 "updates": 0,
             }
 
-        # Load from disk if persistence is enabled and file exists
-        if self.persistence_interval is not None:
-            self._load_from_disk()
-
     def _update_node_freq(self, node: LFUNode) -> None:
         """Update the frequency of a node and move it to the appropriate frequency list."""
         old_freq = node.freq
@@ -175,9 +159,6 @@ def get(self, key: Any, default: Any = None) -> Any:
             The value associated with the key, or default if not found
         """
         with self._lock:
-            # Check if we should persist
-            self._check_and_persist()
-
             # Check if we should log stats
             self._check_and_log_stats()
 
@@ -203,9 +184,6 @@ def put(self, key: Any, value: Any) -> None:
             value: The value to associate with the key
         """
         with self._lock:
-            # Check if we should persist
-            self._check_and_persist()
-
             # Check if we should log stats
             self._check_and_log_stats()
 
@@ -312,109 +290,6 @@ def reset_stats(self) -> None:
                     "updates": 0,
                 }
 
-    def _check_and_persist(self) -> None:
-        """Check if enough time has passed and persist to disk if needed."""
-        if self.persistence_interval is None:
-            return
-
-        current_time = time.time()
-
-        # Initialize timestamp on first check
-        if self.last_persist_time is None:
-            self.last_persist_time = current_time
-            return
-
-        if current_time - self.last_persist_time >= self.persistence_interval:
-            self._persist_to_disk()
-            self.last_persist_time = current_time
-
-    def _persist_to_disk(self) -> None:
-        """
-        Serialize cache to disk.
-
-        Stores cache data as JSON with node information including keys, values,
-        frequencies, and timestamps for reconstruction.
-        """
-        if not self.key_map:
-            # If cache is empty, remove the persistence file
-            if os.path.exists(self.persistence_path):
-                os.remove(self.persistence_path)
-            return
-
-        cache_data = {
-            "capacity": self._capacity,
-            "min_freq": self.min_freq,
-            "nodes": [],
-        }
-
-        # Serialize all nodes
-        for key, node in self.key_map.items():
-            cache_data["nodes"].append(
-                {
-                    "key": key,
-                    "value": node.value,
-                    "freq": node.freq,
-                    "created_at": node.created_at,
-                    "accessed_at": node.accessed_at,
-                }
-            )
-
-        # Write to disk
-        try:
-            with open(self.persistence_path, "w") as f:
-                json.dump(cache_data, f, indent=2)
-        except Exception as e:
-            # Silently fail on persistence errors to not disrupt cache operations
-            pass
-
-    def _load_from_disk(self) -> None:
-        """
-        Load cache from disk if persistence file exists.
-
-        Reconstructs the cache state including frequency lists and node relationships.
-        """
-        if not os.path.exists(self.persistence_path):
-            return
-
-        try:
-            with open(self.persistence_path, "r") as f:
-                cache_data = json.load(f)
-
-            # Reconstruct cache
-            self.min_freq = cache_data.get("min_freq", 0)
-
-            for node_data in cache_data.get("nodes", []):
-                # Create node
-                node = LFUNode(node_data["key"], node_data["value"])
-                node.freq = node_data["freq"]
-                node.created_at = node_data["created_at"]
-                node.accessed_at = node_data["accessed_at"]
-
-                # Add to key map
-                self.key_map[node.key] = node
-
-                # Add to appropriate frequency list
-                if node.freq not in self.freq_map:
-                    self.freq_map[node.freq] = DoublyLinkedList()
-                self.freq_map[node.freq].append(node)
-
-        except Exception as e:
-            # If loading fails, start with empty cache
-            self.key_map.clear()
-            self.freq_map.clear()
-            self.min_freq = 0
-
-    def persist_now(self) -> None:
-        """Force immediate persistence to disk (useful for shutdown)."""
-        with self._lock:
-            if self.persistence_interval is not None:
-                self._persist_to_disk()
-                self.last_persist_time = time.time()
-
-    def supports_persistence(self) -> bool:
-        """Check if this cache instance supports persistence."""
-        return self.persistence_interval is not None
-
     def _check_and_log_stats(self) -> None:
         """Check if enough time has passed and log stats if needed."""
         if not self.track_stats or self.stats_logging_interval is None:
@@ -644,34 +519,3 @@ def capacity(self) -> int:
     # Reset statistics
     stats_cache.reset_stats()
     print(f"\nAfter reset: {stats_cache.get_stats()}")
-
-    print("\n=== Cache with Persistence ===")
-
-    # Create cache with persistence (5 second interval)
-    persist_cache = LFUCache(
-        capacity=3, persistence_interval=5.0, persistence_path="test_cache.json"
-    )
-
-    # Add some items
-    persist_cache.put("item1", "value1")
-    persist_cache.put("item2", "value2")
-    persist_cache.put("item3", "value3")
-
-    # Force immediate persistence
-    persist_cache.persist_now()
-    print("Cache persisted to disk")
-
-    # Create new cache instance that will load from disk
-    new_cache = LFUCache(
-        capacity=3, persistence_interval=5.0, persistence_path="test_cache.json"
-    )
-
-    # Verify data was loaded
-    print(f"Loaded item1: {new_cache.get('item1')}")  # Should return 'value1'
-    print(f"Loaded item2: {new_cache.get('item2')}")  # Should return 'value2'
-    print(f"Cache size after loading: {new_cache.size()}")  # Should return 3
-
-    # Clean up
-    if os.path.exists("test_cache.json"):
-        os.remove("test_cache.json")
-        print("Cleaned up test persistence file")

tests/test_cache_lfu.py

@@ -17,13 +17,11 @@
 Comprehensive test suite for LFU Cache implementation.
 
 Tests all functionality including basic operations, eviction policies,
-capacity management, edge cases, and persistence functionality.
+capacity management, and edge cases.
 """
 
 import asyncio
-import json
 import os
-import tempfile
 import threading
 import time
 import unittest
@@ -368,15 +366,6 @@ def test_interface_methods_exist(self):
 class TestLFUCacheStatsLogging(unittest.TestCase):
     """Test cases for LFU Cache statistics logging functionality."""
 
-    def setUp(self):
-        """Set up test fixtures."""
-        self.test_file = tempfile.mktemp()
-
-    def tearDown(self):
-        """Clean up test files."""
-        if os.path.exists(self.test_file):
-            os.remove(self.test_file)
-
     def test_stats_logging_disabled_by_default(self):
         """Test that stats logging is disabled when not configured."""
         cache = LFUCache(5, track_stats=True)
@@ -644,15 +633,6 @@ def test_stats_log_format_percentages(self):
 class TestContentSafetyCacheStatsConfig(unittest.TestCase):
     """Test cache stats configuration in content safety context."""
 
-    def setUp(self):
-        """Set up test fixtures."""
-        self.test_file = tempfile.mktemp()
-
-    def tearDown(self):
-        """Clean up test files."""
-        if os.path.exists(self.test_file):
-            os.remove(self.test_file)
-
     def test_cache_config_with_stats_disabled(self):
         """Test cache configuration with stats disabled."""
         from nemoguardrails.rails.llm.config import CacheStatsConfig, ModelCacheConfig
@@ -1193,11 +1173,11 @@ def worker(thread_id):
                         f"Wrong value for {key}: expected {value}, got {retrieved}"
                     )
 
-                # Also work with some persistent keys (access multiple times)
-                persistent_key = f"persistent_{thread_id % 5}"
+                # Also work with some high-frequency keys (access multiple times)
+                high_freq_key = f"high_freq_{thread_id % 5}"
                 for _ in range(3):  # Access 3 times to increase frequency
-                    small_cache.put(persistent_key, f"persistent_value_{thread_id}")
-                    small_cache.get(persistent_key)
+                    small_cache.put(high_freq_key, f"high_freq_value_{thread_id}")
+                    small_cache.get(high_freq_key)
 
         # Run workers
         with ThreadPoolExecutor(max_workers=10) as executor: