tellaro-query-language 0.2.5__tar.gz → 0.2.6__tar.gz

{tellaro_query_language-0.2.5 → tellaro_query_language-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tellaro-query-language
-Version: 0.2.5
+Version: 0.2.6
 Summary: A flexible, human-friendly query language for searching and filtering structured data
 Home-page: https://github.com/tellaro/tellaro-query-language
 License: Proprietary

{tellaro_query_language-0.2.5 → tellaro_query_language-0.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "tellaro-query-language"
-version = "0.2.5"
+version = "0.2.6"
 description = "A flexible, human-friendly query language for searching and filtering structured data"
 authors = ["Justin Henderson <justin@tellaro.io>"]
 license = "Proprietary"
@@ -77,6 +77,7 @@ types-setuptools = "^75.8.2.20250305"
 opensearch-dsl = "^2.1.0"
 python-dotenv = "^1.1.0"
 jupyter = "^1.1.1"
+redis = "^7.1.0"
 
 [build-system]
 requires = ["poetry-core"]

{tellaro_query_language-0.2.5 → tellaro_query_language-0.2.6}/src/tql/cache/base.py

@@ -40,7 +40,7 @@ class CacheManager:
         """
         return None
 
-    def set(self, key: str, value: Any, ttl: Optional[int] = None) -> None:
+    def set(self, key: str, value: Any, ttl: Optional[int] = None) -> bool:
         """Store a value in the cache.
 
         Args:
@@ -48,20 +48,54 @@ class CacheManager:
             value: The value to cache. Can be any Python object.
             ttl: Time-to-live in seconds. If None or 0, the value never expires.
 
+        Returns:
+            True if the value was successfully stored.
+
         Example:
             >>> cache.set("config", {"debug": True}, ttl=300)  # Cache for 5 minutes
             >>> cache.set("permanent", {"version": "1.0"})  # Never expires
         """
+        return True
 
-    def delete(self, key: str) -> None:
+    def delete(self, key: str) -> bool:
         """Remove a value from the cache.
 
         Args:
             key: The cache key to delete.
 
+        Returns:
+            True if the key existed and was deleted, False otherwise.
+
         Example:
             >>> cache.delete("expired_key")
         """
+        return False
+
+    def exists(self, key: str) -> bool:  # pylint: disable=unused-argument
+        """Check if a key exists in the cache.
+
+        Args:
+            key: The cache key to check.
+
+        Returns:
+            True if the key exists and hasn't expired, False otherwise.
+
+        Example:
+            >>> if cache.exists("my_key"):
+            ...     value = cache.get("my_key")
+        """
+        return False
+
+    def clear(self) -> bool:
+        """Clear all items from the cache.
+
+        Returns:
+            True if the cache was successfully cleared.
+
+        Example:
+            >>> cache.clear()
+        """
+        return True
 
     def clear_pattern(self, pattern: str) -> int:  # pylint: disable=unused-argument
         """Clear all keys matching a pattern.

{tellaro_query_language-0.2.5 → tellaro_query_language-0.2.6}/src/tql/cache/memory.py

@@ -78,7 +78,7 @@ class LocalCacheManager(CacheManager):
         self._misses += 1
         return None
 
-    def set(self, key: str, value: Any, ttl: Optional[int] = None) -> None:
+    def set(self, key: str, value: Any, ttl: Optional[int] = None) -> bool:
         """Store value in cache with optional TTL.
 
         Args:
@@ -87,6 +87,9 @@ class LocalCacheManager(CacheManager):
             ttl: Time-to-live in seconds. If None, uses default_ttl.
                  If 0, the item never expires.
 
+        Returns:
+            True if the value was successfully stored.
+
         Note:
             When the cache is full (reaches max_size), the oldest item
             is evicted to make room for the new one (LRU eviction).
@@ -104,18 +107,62 @@ class LocalCacheManager(CacheManager):
         else:
             expiry_time = time.time() + (ttl if ttl is not None else self.default_ttl)
             self._expiry[key] = expiry_time
+        return True
 
-    def delete(self, key: str) -> None:
+    def delete(self, key: str) -> bool:
         """Remove value from cache.
 
         Args:
             key: The cache key to delete.
 
+        Returns:
+            True if the key existed and was deleted, False otherwise.
+
+        Note:
+            If the key doesn't exist, this method returns False (no error raised).
+        """
+        if key in self._cache:
+            del self._cache[key]
+            self._expiry.pop(key, None)
+            return True
+        return False
+
+    def exists(self, key: str) -> bool:
+        """Check if a key exists in the cache and hasn't expired.
+
+        Args:
+            key: The cache key to check.
+
+        Returns:
+            True if the key exists and hasn't expired, False otherwise.
+
         Note:
-            If the key doesn't exist, this method does nothing (no error raised).
+            This method automatically removes expired keys when accessed.
         """
-        self._cache.pop(key, None)
-        self._expiry.pop(key, None)
+        if key in self._cache:
+            expiry = self._expiry.get(key, float("inf"))
+            if expiry == 0 or expiry > time.time():
+                return True
+            else:
+                # Expired - clean up
+                del self._cache[key]
+                del self._expiry[key]
+        return False
+
+    def clear(self) -> bool:
+        """Clear all items from the cache.
+
+        Returns:
+            True if the cache was successfully cleared.
+
+        Note:
+            This also resets hit/miss statistics.
+        """
+        self._cache.clear()
+        self._expiry.clear()
+        self._hits = 0
+        self._misses = 0
+        return True
 
     def clear_pattern(self, pattern: str) -> int:
         """Clear all keys matching a glob pattern.

{tellaro_query_language-0.2.5 → tellaro_query_language-0.2.6}/src/tql/cache/redis.py

@@ -3,13 +3,14 @@
 import json
 from typing import Any, Dict, Optional
 
+from .base import CacheManager
+
+redis: Any
 try:
     import redis
 except ImportError:
     redis = None
 
-from .base import CacheManager
-
 
 class RedisCacheManager(CacheManager):
     """Redis-based distributed cache."""
@@ -33,16 +34,56 @@ class RedisCacheManager(CacheManager):
             return json.loads(value)
         return None
 
-    def set(self, key: str, value: Any, ttl: Optional[int] = None) -> None:
-        """Store value in Redis with TTL."""
-        full_key = self._make_key(key)
-        ttl = ttl or self.default_ttl
-        self.redis.setex(full_key, ttl, json.dumps(value))
+    def set(self, key: str, value: Any, ttl: Optional[int] = None) -> bool:
+        """Store value in Redis with TTL.
 
-    def delete(self, key: str) -> None:
-        """Remove value from Redis."""
-        full_key = self._make_key(key)
-        self.redis.delete(full_key)
+        Returns:
+            True if the value was successfully stored.
+        """
+        try:
+            full_key = self._make_key(key)
+            ttl = ttl or self.default_ttl
+            self.redis.setex(full_key, ttl, json.dumps(value))
+            return True
+        except Exception:
+            return False
+
+    def delete(self, key: str) -> bool:
+        """Remove value from Redis.
+
+        Returns:
+            True if the key existed and was deleted, False otherwise.
+        """
+        try:
+            full_key = self._make_key(key)
+            result = self.redis.delete(full_key)
+            return result > 0
+        except Exception:
+            return False
+
+    def exists(self, key: str) -> bool:
+        """Check if a key exists in Redis.
+
+        Returns:
+            True if the key exists, False otherwise.
+        """
+        try:
+            full_key = self._make_key(key)
+            return self.redis.exists(full_key) > 0
+        except Exception:
+            return False
+
+    def clear(self) -> bool:
+        """Clear all keys in the Redis database.
+
+        Returns:
+            True if the cache was successfully cleared.
+        """
+        try:
+            self.redis.flushdb()
+            return True
+        except Exception:
+            return False
 
     def clear_pattern(self, pattern: str) -> int:
         """Clear all keys matching pattern."""