altcodepro-polydb-python 2.2.6__tar.gz → 2.2.8__tar.gz

{altcodepro_polydb_python-2.2.6/src/altcodepro_polydb_python.egg-info → altcodepro_polydb_python-2.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.2.6
+Version: 2.2.8
 Summary: Production-ready multi-cloud database abstraction layer with connection pooling, retry logic, and thread safety
 Author: AltCodePro
 Project-URL: Homepage, https://github.com/altcodepro/polydb-python

{altcodepro_polydb_python-2.2.6 → altcodepro_polydb_python-2.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "altcodepro-polydb-python"
-version = "2.2.6"
+version = "2.2.8"
 description = "Production-ready multi-cloud database abstraction layer with connection pooling, retry logic, and thread safety"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.8"

{altcodepro_polydb_python-2.2.6 → altcodepro_polydb_python-2.2.8/src/altcodepro_polydb_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.2.6
+Version: 2.2.8
 Summary: Production-ready multi-cloud database abstraction layer with connection pooling, retry logic, and thread safety
 Author: AltCodePro
 Project-URL: Homepage, https://github.com/altcodepro/polydb-python

{altcodepro_polydb_python-2.2.6 → altcodepro_polydb_python-2.2.8}/src/polydb/cache.py

@@ -10,8 +10,10 @@ from enum import Enum
 import redis
 from .json_safe import json_safe
 
+
 class CacheStrategy(Enum):
     """Cache invalidation strategies"""
+
     LRU = "lru"  # Least Recently Used
     LFU = "lfu"  # Least Frequently Used
     TTL = "ttl"  # Time To Live
@@ -21,12 +23,9 @@ class CacheStrategy(Enum):
 
 class RedisCacheEngine:
     """Redis-based distributed cache"""
-    
+
     def __init__(
-        self,
-        redis_url: Optional[str] = None,
-        prefix: str = "polydb:",
-        default_ttl: int = 3600
+        self, redis_url: Optional[str] = None, prefix: str = "polydb:", default_ttl: int = 3600
     ):
         self.prefix = prefix
         self.default_ttl = default_ttl
@@ -34,7 +33,7 @@ class RedisCacheEngine:
         self._lock = threading.Lock()
         self.redis_url = redis_url
         self._initialize()
-    
+
     def _initialize(self):
         """Initialize Redis connection"""
         try:
@@ -44,32 +43,30 @@ class RedisCacheEngine:
                         self._client = redis.from_url(self.redis_url)
                     else:
                         import os
-                        redis_host = os.getenv('REDIS_HOST', 'localhost')
-                        redis_port = int(os.getenv('REDIS_PORT', '6379'))
-                        redis_db = int(os.getenv('REDIS_DB', '0'))
-                        
+
+                        redis_host = os.getenv("REDIS_HOST", "localhost")
+                        redis_port = int(os.getenv("REDIS_PORT", "6379"))
+                        redis_db = int(os.getenv("REDIS_DB", "0"))
+
                         self._client = redis.Redis(
-                            host=redis_host,
-                            port=redis_port,
-                            db=redis_db,
-                            decode_responses=True
+                            host=redis_host, port=redis_port, db=redis_db, decode_responses=True
                         )
         except ImportError:
             raise ImportError("Redis not installed. Install with: pip install redis")
-    
+
     def _make_key(self, model: str, query: Dict[str, Any]) -> str:
         """Generate cache key"""
-        query_str = json.dumps(query, sort_keys=True,default=json_safe)
+        query_str = json.dumps(query, sort_keys=True, default=json_safe)
         query_hash = hashlib.md5(query_str.encode()).hexdigest()
         return f"{self.prefix}{model}:{query_hash}"
-    
+
     def get(self, model: str, query: Dict[str, Any]) -> Optional[Any]:
         """Get from cache"""
         if not self._client:
             return None
-        
+
         key = self._make_key(model, query)
-        
+
         try:
             data = self._client.get(key)
             if data:
@@ -79,39 +76,29 @@ class RedisCacheEngine:
             return None
         except Exception:
             return None
-    
-    def set(
-        self,
-        model: str,
-        query: Dict[str, Any],
-        value: Any,
-        ttl: Optional[int] = None
-    ):
+
+    def set(self, model: str, query: Dict[str, Any], value: Any, ttl: Optional[int] = None):
         """Set cache with TTL"""
         if not self._client:
             return
-        
+
         key = self._make_key(model, query)
         ttl = ttl or self.default_ttl
-        
+
         try:
-            data = json.dumps(value,default=json_safe)
+            data = json.dumps(value, default=json_safe)
             self._client.setex(key, ttl, data)
-            
+
             # Initialize access count
             self._client.set(f"{key}:access_count", 0, ex=ttl)
         except Exception:
             pass
-    
-    def invalidate(
-        self,
-        model: str,
-        query: Optional[Dict[str, Any]] = None
-    ):
+
+    def invalidate(self, model: str, query: Optional[Dict[str, Any]] = None):
         """Invalidate cache"""
         if not self._client:
             return
-        
+
         if query:
             key = self._make_key(model, query)
             self._client.delete(key, f"{key}:access_count")
@@ -121,66 +108,122 @@ class RedisCacheEngine:
             keys = self._client.keys(pattern)
             if keys:
                 self._client.delete(*keys)
-    
+
     def clear(self):
         """Clear entire cache"""
         if not self._client:
             return
-        
+
         pattern = f"{self.prefix}*"
         keys = self._client.keys(pattern)
         if keys:
             self._client.delete(*keys)
-    
+
     def get_stats(self) -> Dict[str, Any]:
         """Get cache statistics"""
         if not self._client:
             return {}
-        
+
         try:
-            info = self._client.info('stats')
+            info = self._client.info("stats")
             return {
-                'hits': info.get('keyspace_hits', 0),
-                'misses': info.get('keyspace_misses', 0),
-                'hit_rate': info.get('keyspace_hits', 0) / 
-                           max(info.get('keyspace_hits', 0) + info.get('keyspace_misses', 0), 1)
+                "hits": info.get("keyspace_hits", 0),
+                "misses": info.get("keyspace_misses", 0),
+                "hit_rate": info.get("keyspace_hits", 0)
+                / max(info.get("keyspace_hits", 0) + info.get("keyspace_misses", 0), 1),
             }
         except Exception:
             return {}
 
+    # ---------------------------------------------------------
+    # ZSET (Sorted Set) Operations — for rate limiting, ranking
+    # ---------------------------------------------------------
+
+    def _make_raw_key(self, model: str, key: str) -> str:
+        """Direct key (no hashing) for structured use cases like rate limiting"""
+        return f"{self.prefix}{model}:{key}"
+
+    def zadd(self, model: str, key: str, mapping: Dict[str, float]) -> None:
+        if not self._client:
+            return
+
+        redis_key = self._make_raw_key(model, key)
+
+        try:
+            self._client.zadd(redis_key, mapping)
+        except Exception:
+            pass
+
+    def zcard(self, model: str, key: str) -> int:
+        if not self._client:
+            return 0
+
+        redis_key = self._make_raw_key(model, key)
+
+        try:
+            return int(self._client.zcard(redis_key))
+        except Exception:
+            return 0
+
+    def zremrangebyscore(
+        self,
+        model: str,
+        key: str,
+        min_score: float,
+        max_score: float,
+    ) -> None:
+        if not self._client:
+            return
+
+        redis_key = self._make_raw_key(model, key)
+
+        try:
+            self._client.zremrangebyscore(redis_key, min_score, max_score)
+        except Exception:
+            pass
+
+    def expire_key(self, model: str, key: str, ttl: int) -> None:
+        if not self._client:
+            return
+
+        redis_key = self._make_raw_key(model, key)
+
+        try:
+            self._client.expire(redis_key, ttl)
+        except Exception:
+            pass
+
+    def delete_key(self, model: str, key: str) -> None:
+        if not self._client:
+            return
+
+        redis_key = self._make_raw_key(model, key)
+
+        try:
+            self._client.delete(redis_key)
+        except Exception:
+            pass
+
 
 class CacheWarmer:
     """Pre-populate cache with frequently accessed data"""
-    
+
     def __init__(self, factory, cache_engine):
         self.factory = factory
         self.cache = cache_engine
-    
-    def warm_model(
-        self,
-        model,
-        queries: List[Dict[str, Any]],
-        ttl: Optional[int] = None
-    ):
+
+    def warm_model(self, model, queries: List[Dict[str, Any]], ttl: Optional[int] = None):
         """Warm cache for specific queries"""
         for query in queries:
             try:
                 results = self.factory.read(model, query=query)
                 self.cache.set(
-                    model.__name__ if isinstance(model, type) else model,
-                    query,
-                    results,
-                    ttl
+                    model.__name__ if isinstance(model, type) else model, query, results, ttl
                 )
             except Exception:
                 pass
-    
-    def warm_popular_queries(
-        self,
-        model,
-        limit: int = 10,
-        ttl: Optional[int] = None
-    ):
+
+    def warm_popular_queries(self, model, limit: int = 10, ttl: Optional[int] = None):
         """Warm cache with most popular queries"""
         # This would need query log analysis
         # Placeholder implementation
@@ -189,17 +232,17 @@ class CacheWarmer:
 
 class CacheInvalidationStrategy:
     """Manages cache invalidation strategies"""
-    
+
     def __init__(self, cache_engine, strategy: CacheStrategy = CacheStrategy.TTL):
         self.cache = cache_engine
         self.strategy = strategy
-    
+
     def invalidate_on_write(self, model: str, data: Dict[str, Any]):
         """Invalidate cache on write operations"""
         if self.strategy in [CacheStrategy.WRITE_THROUGH, CacheStrategy.WRITE_BACK]:
             self.cache.invalidate(model)
-    
+
     def invalidate_related(self, model: str, relationships: List[str]):
         """Invalidate related models"""
         for related in relationships:
-            self.cache.invalidate(related)
+            self.cache.invalidate(related)