llmasajudge 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

llmasajudge/__init__.py

@@ -214,6 +214,125 @@ from litellm.caching.caching import Cache
 __all__ = ["LLMAsAJudge", "OutputParsers"]
 
 
+class UnlimitedDiskCache:
+    """
+    Drop-in replacement backend with 'unlimited' size for LiteLLM cache.
+
+    This wraps diskcache.Cache with a very large size limit (2^62 bytes ~ 4.6 exabytes)
+    to effectively disable automatic cache eviction, allowing the cache to grow
+    without size constraints.
+    """
+
+    def __init__(self, directory, size_limit=None):
+        """
+        Initialize unlimited disk cache.
+
+        Args:
+            directory: Path to cache directory
+            size_limit: Optional size limit in bytes. If None, uses 2^62 bytes (~4.6 exabytes)
+        """
+        import diskcache as dc
+
+        # Set to very large cap so culling never triggers (effectively unlimited)
+        cap = size_limit if size_limit is not None else (1 << 62)
+        self._dc = dc.Cache(directory, size_limit=cap)
+
+    # Sync API used by LiteLLM
+    def get_cache(self, key, **kwargs):
+        """Get value from cache by key."""
+        return self._dc.get(key)
+
+    def set_cache(self, key, value, ttl=None, **kwargs):
+        """Set value in cache with optional TTL."""
+        expire = None if ttl is None else float(ttl)
+        self._dc.set(key, value, expire=expire)
+
+    # Async API used by LiteLLM
+    async def async_get_cache(self, key, **kwargs):
+        """Async get value from cache by key."""
+        return self.get_cache(key, **kwargs)
+
+    async def async_set_cache(self, key, value, ttl=None, **kwargs):
+        """Async set value in cache with optional TTL."""
+        return self.set_cache(key, value, ttl=ttl, **kwargs)
+
+    async def async_set_cache_pipeline(self, cache_list, ttl=None, **kwargs):
+        """
+        Async batch set multiple cache entries.
+
+        Args:
+            cache_list: List of (key, value) tuples
+            ttl: Optional time-to-live in seconds
+        """
+        for k, v in cache_list:
+            self.set_cache(k, v, ttl=ttl)
+
+    async def batch_cache_write(self, key, value, ttl=None, **kwargs):
+        """Async batch write (single entry)."""
+        self.set_cache(key, value, ttl=ttl)
+
+    async def ping(self):
+        """Async ping check."""
+        return True
+
+    async def delete_cache_keys(self, keys):
+        """
+        Async delete multiple cache keys.
+
+        Args:
+            keys: List of keys to delete
+        """
+        for k in keys:
+            try:
+                del self._dc[k]
+            except KeyError:
+                pass
+        return True
+
+    async def disconnect(self):
+        """Async disconnect and close cache."""
+        self._dc.close()
+
+    def get_stats(self):
+        """
+        Get cache statistics.
+
+        Returns:
+            dict with size_limit, current_size, item_count, and percent_full
+        """
+        size_limit = self._dc.size_limit
+        volume = self._dc.volume()  # Current size in bytes
+        count = len(self._dc)  # Number of items
+
+        return {
+            "size_limit": size_limit,
+            "current_size": volume,
+            "item_count": count,
+            "percent_full": (volume / size_limit) * 100 if size_limit > 0 else 0.0,
+        }
+
+    def print_stats(self):
+        """Print human-readable cache statistics."""
+        stats = self.get_stats()
+
+        def human_size(bytes_val):
+            """Convert bytes to human readable format."""
+            for unit in ["B", "KB", "MB", "GB", "TB", "PB", "EB"]:
+                if bytes_val < 1024.0:
+                    return f"{bytes_val:.2f} {unit}"
+                bytes_val /= 1024.0
+            return f"{bytes_val:.2f} EB"
+
+        print("=" * 60)
+        print("CACHE STATISTICS")
+        print("=" * 60)
+        print(f"  Size limit:     {human_size(stats['size_limit'])} ({stats['size_limit']:,} bytes)")
+        print(f"  Current size:   {human_size(stats['current_size'])} ({stats['current_size']:,} bytes)")
+        print(f"  Items cached:   {stats['item_count']}")
+        print(f"  % full:         {stats['percent_full']:.6f}%")
+        print("=" * 60)
+
+
 class OutputParsers:
     """Stock output parsers for common judge output formats."""
 
@@ -455,7 +574,9 @@ Output only the number. No explanation. No extra text.""",
         backoff_max: float = 4.0,
         custom_generation_fns: Optional[List[Callable[[str], str]]] = None,
         mode: str = "majority",
+        use_cache: bool = False,
         litellm_cache_dir: Optional[str] = None,
+        cache_size_gb: Optional[float] = None,
     ):
         self.models = models or []
         self.custom_generation_fns = custom_generation_fns or []
@@ -516,9 +637,20 @@ Output only the number. No explanation. No extra text.""",
             )
 
         # optional local cache setup
-        self.cache_enabled = litellm_cache_dir is not None
+        # Enable cache if use_cache=True OR if litellm_cache_dir is explicitly provided (backward compatible)
+        self.cache_enabled = use_cache or (litellm_cache_dir is not None)
         if self.cache_enabled:
-            litellm.cache = Cache(type="disk", disk_cache_dir=litellm_cache_dir)
+            # Only set up cache if it hasn't been set up already
+            if litellm.cache is None:
+                # Set default cache directory if not specified
+                if litellm_cache_dir is None:
+                    litellm_cache_dir = ".litellm_cache"
+
+                # Convert GB to bytes if specified, otherwise unlimited
+                size_limit_bytes = None if cache_size_gb is None else int(cache_size_gb * 1024 * 1024 * 1024)
+                cache_backend = UnlimitedDiskCache(litellm_cache_dir, size_limit=size_limit_bytes)
+                litellm.cache = Cache(disk_cache_dir=litellm_cache_dir)
+                litellm.cache.cache = cache_backend
 
 
 

{llmasajudge-0.1.11.dist-info → llmasajudge-0.1.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llmasajudge
-Version: 0.1.11
+Version: 0.1.13
 Summary: LLM Judge: simple right/wrong voting across models
 Author-email: Brett Young <byyoung3@gmail.com>
 Project-URL: Homepage, https://example.com

llmasajudge-0.1.13.dist-info/RECORD

@@ -0,0 +1,5 @@
+llmasajudge/__init__.py,sha256=u_92YWEEMEPnAxb_uyUiOsn7tkD5x2Z4_ZlAihT9STY,32405
+llmasajudge-0.1.13.dist-info/METADATA,sha256=uuYRR5rYdvvEF8Pcx3Qheo58l3CXgIWzOzC7om6uCbQ,515
+llmasajudge-0.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+llmasajudge-0.1.13.dist-info/top_level.txt,sha256=rRaIpM1llpEqahR9flT3RjpZHi2o16iOgnGYJ8cO4_0,12
+llmasajudge-0.1.13.dist-info/RECORD,,

llmasajudge-0.1.11.dist-info/RECORD

@@ -1,5 +0,0 @@
-llmasajudge/__init__.py,sha256=IkCie_90ABggVrtTVXKhf1VSLgWQ9qRrAb9VN0I0uSo,27626
-llmasajudge-0.1.11.dist-info/METADATA,sha256=rTP1z67wo_ewBiMIx8819MiWjmXqtOno9mfBH0aRpwc,515
-llmasajudge-0.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-llmasajudge-0.1.11.dist-info/top_level.txt,sha256=rRaIpM1llpEqahR9flT3RjpZHi2o16iOgnGYJ8cO4_0,12
-llmasajudge-0.1.11.dist-info/RECORD,,