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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.2.8
+Version: 2.2.9
 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.8 → altcodepro_polydb_python-2.2.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "altcodepro-polydb-python"
-version = "2.2.8"
+version = "2.2.9"
 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.8 → altcodepro_polydb_python-2.2.9/src/altcodepro_polydb_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.2.8
+Version: 2.2.9
 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.8 → altcodepro_polydb_python-2.2.9}/src/polydb/cloudDatabaseFactory.py

@@ -4,7 +4,8 @@ import os
 import threading
 from typing import Dict, List, Optional
 
-
+from .adapters.AzureFileStorageAdapter import AzureFileStorageAdapter
+from .adapters.EFSAdapter import EFSAdapter
 from .adapters.PostgreSQLAdapter import PostgreSQLAdapter
 from .adapters.AzureBlobStorageAdapter import AzureBlobStorageAdapter
 from .adapters.BlockchainBlobAdapter import BlockchainBlobAdapter
@@ -441,7 +442,17 @@ class CloudDatabaseFactory:
             self.instances["queue"] = instance
             return instance
 
-    def get_files(self, name: str = "files"):
+    def get_files(
+        self, name: str = "files"
+    ) -> (
+        AzureFileStorageAdapter
+        | EFSAdapter
+        | GCPStorageAdapter
+        | AzureBlobStorageAdapter
+        | S3CompatibleAdapter
+        | VercelBlobAdapter
+        | BlockchainBlobAdapter
+    ):
         with self._lock:
             if name in self.instances:
                 return self.instances[name]

{altcodepro_polydb_python-2.2.8 → altcodepro_polydb_python-2.2.9}/src/polydb/databaseFactory.py

@@ -110,8 +110,6 @@ def _extract_meta(model: Union[type, str]) -> ModelMeta:
                 provider=raw.get("provider"),
                 cache=raw.get("cache", False),
                 cache_ttl=raw.get("cache_ttl"),
-                encrypted_fields=raw.get("encrypted_fields", []),
-                soft_delete=raw.get("soft_delete", False),
             )
     # Default for dynamic/string models
     return ModelMeta(storage="nosql", table=None, collection=None)
@@ -480,13 +478,13 @@ class DatabaseFactory:
                 )
             if self.encryption and encrypted_fields:
                 raw = [self.encryption.decrypt_fields(r, encrypted_fields) for r in raw]
-            if use_external_cache and not no_cache:
+            if self._cache and use_external_cache and not no_cache:
                 ttl = cache_ttl or getattr(meta, "cache_ttl", 300)
                 self._cache.set(name, query or {}, raw, ttl)
             return raw
 
         # Check external cache first
-        if use_external_cache and not no_cache:
+        if self._cache and use_external_cache and not no_cache:
             cached = self._cache.get(name, query or {})
             if cached is not None:
                 return cached
@@ -923,11 +921,11 @@ class DatabaseFactory:
         self, path: str, data: Union[bytes, str], *, adapter_name: str = "files"
     ) -> bool:
         files = self._engines[0].cloud_factory.get_files(adapter_name)
-        return files.write(path, data.encode() if isinstance(data, str) else data)
+        return files.write(path, data.encode() if isinstance(data, str) else data)  # type: ignore
 
     def read_file(self, path: str, *, adapter_name: str = "files") -> Optional[bytes]:
         files = self._engines[0].cloud_factory.get_files(adapter_name)
-        return files.read(path)
+        return files.read(path)  # type: ignore
 
     def delete_file(self, path: str, *, adapter_name: str = "files") -> bool:
         files = self._engines[0].cloud_factory.get_files(adapter_name)

{altcodepro_polydb_python-2.2.8 → altcodepro_polydb_python-2.2.9}/src/polydb/monitoring.py

@@ -14,6 +14,7 @@ import logging
 @dataclass
 class QueryMetrics:
     """Metrics for a single query"""
+
     operation: str
     model: str
     duration_ms: float
@@ -29,12 +30,13 @@ class QueryMetrics:
 @dataclass
 class AggregatedMetrics:
     """Aggregated metrics over time window"""
+
     total_queries: int = 0
     successful_queries: int = 0
     failed_queries: int = 0
     total_duration_ms: float = 0.0
     avg_duration_ms: float = 0.0
-    min_duration_ms: float = float('inf')
+    min_duration_ms: float = float("inf")
     max_duration_ms: float = 0.0
     cache_hit_rate: float = 0.0
     queries_by_operation: Dict[str, int] = field(default_factory=dict)
@@ -44,117 +46,113 @@ class AggregatedMetrics:
 
 class MetricsCollector:
     """Collects and aggregates metrics"""
-    
+
     def __init__(self, slow_query_threshold_ms: float = 1000.0):
         self.slow_query_threshold = slow_query_threshold_ms
         self._metrics: List[QueryMetrics] = []
         self._lock = threading.Lock()
         self._hooks: List[Callable] = []
         self.logger = logging.getLogger(__name__)
-    
+
     def record(self, metric: QueryMetrics):
         """Record a query metric"""
         with self._lock:
             self._metrics.append(metric)
-            
+
             # Log slow queries
             if metric.duration_ms > self.slow_query_threshold:
                 self.logger.warning(
                     f"Slow query detected: {metric.operation} on {metric.model} "
                     f"took {metric.duration_ms:.2f}ms"
                 )
-            
+
             # Trigger hooks
             for hook in self._hooks:
                 try:
                     hook(metric)
                 except Exception as e:
                     self.logger.error(f"Metrics hook failed: {e}")
-    
+
     def register_hook(self, hook: Callable[[QueryMetrics], None]):
         """Register a metrics hook"""
         self._hooks.append(hook)
-    
+
     def get_metrics(
         self,
         since: Optional[datetime] = None,
         model: Optional[str] = None,
-        operation: Optional[str] = None
+        operation: Optional[str] = None,
     ) -> List[QueryMetrics]:
         """Get filtered metrics"""
         with self._lock:
             metrics = self._metrics.copy()
-        
+
         if since:
             metrics = [m for m in metrics if m.timestamp >= since]
-        
+
         if model:
             metrics = [m for m in metrics if m.model == model]
-        
+
         if operation:
             metrics = [m for m in metrics if m.operation == operation]
-        
+
         return metrics
-    
+
     def aggregate(
-        self,
-        since: Optional[datetime] = None,
-        model: Optional[str] = None
+        self, since: Optional[datetime] = None, model: Optional[str] = None
     ) -> AggregatedMetrics:
         """Generate aggregated metrics"""
         metrics = self.get_metrics(since=since, model=model)
-        
+
         if not metrics:
             return AggregatedMetrics()
-        
+
         agg = AggregatedMetrics()
         agg.total_queries = len(metrics)
-        
+
         durations = []
         cache_hits = 0
-        
+
         for m in metrics:
             if m.success:
                 agg.successful_queries += 1
             else:
                 agg.failed_queries += 1
-            
+
             durations.append(m.duration_ms)
             agg.total_duration_ms += m.duration_ms
-            
+
             if m.cache_hit:
                 cache_hits += 1
-            
+
             # Count by operation
-            agg.queries_by_operation[m.operation] = \
-                agg.queries_by_operation.get(m.operation, 0) + 1
-            
+            agg.queries_by_operation[m.operation] = agg.queries_by_operation.get(m.operation, 0) + 1
+
             # Count by model
-            agg.queries_by_model[m.model] = \
-                agg.queries_by_model.get(m.model, 0) + 1
-            
+            agg.queries_by_model[m.model] = agg.queries_by_model.get(m.model, 0) + 1
+
             # Track slow queries
             if m.duration_ms > self.slow_query_threshold:
                 agg.slow_queries.append(m)
-        
+
         agg.avg_duration_ms = agg.total_duration_ms / agg.total_queries
         agg.min_duration_ms = min(durations)
         agg.max_duration_ms = max(durations)
         agg.cache_hit_rate = cache_hits / agg.total_queries
-        
+
         return agg
-    
+
     def clear_old_metrics(self, older_than: timedelta):
         """Clear metrics older than specified duration"""
         cutoff = datetime.utcnow() - older_than
-        
+
         with self._lock:
             self._metrics = [m for m in self._metrics if m.timestamp >= cutoff]
-    
+
     def export_prometheus(self) -> str:
         """Export metrics in Prometheus format"""
         agg = self.aggregate()
-        
+
         lines = [
             f"# HELP polydb_queries_total Total number of queries",
             f"# TYPE polydb_queries_total counter",
@@ -177,20 +175,20 @@ class MetricsCollector:
             f"# TYPE polydb_cache_hit_rate gauge",
             f"polydb_cache_hit_rate {agg.cache_hit_rate}",
         ]
-        
+
         return "\n".join(lines)
 
 
 class PerformanceMonitor:
     """Context manager for automatic query timing"""
-    
+
     def __init__(
         self,
         collector: MetricsCollector,
         operation: str,
         model: str,
         tenant_id: Optional[str] = None,
-        actor_id: Optional[str] = None
+        actor_id: Optional[str] = None,
     ):
         self.collector = collector
         self.operation = operation
@@ -200,21 +198,22 @@ class PerformanceMonitor:
         self.start_time = None
         self.success = False
         self.error = None
-        self.rows_affected = None
+        self.rows_affected = 0
+        self.rows_returned = 0
         self.cache_hit = False
-    
+
     def __enter__(self):
         self.start_time = time.perf_counter()
         return self
-    
+
     def __exit__(self, exc_type, exc_val, exc_tb):
-        duration_ms = (time.perf_counter() - self.start_time) * 1000 # type: ignore
-        
+        duration_ms = (time.perf_counter() - self.start_time) * 1000  # type: ignore
+
         if exc_type is None:
             self.success = True
         else:
             self.error = str(exc_val)
-        
+
         metric = QueryMetrics(
             operation=self.operation,
             model=self.model,
@@ -224,40 +223,36 @@ class PerformanceMonitor:
             tenant_id=self.tenant_id,
             actor_id=self.actor_id,
             rows_affected=self.rows_affected,
-            cache_hit=self.cache_hit
+            cache_hit=self.cache_hit,
         )
-        
+
         self.collector.record(metric)
-        
+
         return False
 
 
 class HealthCheck:
     """System health monitoring"""
-    
+
     def __init__(self, factory):
         self.factory = factory
         self.logger = logging.getLogger(__name__)
-    
+
     def check_sql_health(self) -> Dict[str, Any]:
         """Check SQL database health"""
         try:
             start = time.perf_counter()
             self.factory._sql.execute("SELECT 1", fetch_one=True)
             duration_ms = (time.perf_counter() - start) * 1000
-            
+
             return {
-                'status': 'healthy',
-                'latency_ms': duration_ms,
-                'provider': self.factory._provider_name
+                "status": "healthy",
+                "latency_ms": duration_ms,
+                "provider": self.factory._provider_name,
             }
         except Exception as e:
-            return {
-                'status': 'unhealthy',
-                'error': str(e),
-                'provider': self.factory._provider_name
-            }
-    
+            return {"status": "unhealthy", "error": str(e), "provider": self.factory._provider_name}
+
     def check_nosql_health(self) -> Dict[str, Any]:
         """Check NoSQL database health"""
         try:
@@ -265,49 +260,39 @@ class HealthCheck:
             start = time.perf_counter()
             # This would need a test model
             duration_ms = (time.perf_counter() - start) * 1000
-            
+
             return {
-                'status': 'healthy',
-                'latency_ms': duration_ms,
-                'provider': self.factory._provider_name
+                "status": "healthy",
+                "latency_ms": duration_ms,
+                "provider": self.factory._provider_name,
             }
         except Exception as e:
-            return {
-                'status': 'unhealthy',
-                'error': str(e),
-                'provider': self.factory._provider_name
-            }
-    
+            return {"status": "unhealthy", "error": str(e), "provider": self.factory._provider_name}
+
     def check_cache_health(self) -> Dict[str, Any]:
         """Check cache health"""
         if not self.factory._cache:
-            return {'status': 'disabled'}
-        
+            return {"status": "disabled"}
+
         try:
             # Test cache operations
             test_key = "_health_check"
             test_value = {"test": True}
-            
+
             start = time.perf_counter()
             self.factory._cache.set(test_key, {}, test_value, 10)
             retrieved = self.factory._cache.get(test_key, {})
             duration_ms = (time.perf_counter() - start) * 1000
-            
-            return {
-                'status': 'healthy',
-                'latency_ms': duration_ms
-            }
+
+            return {"status": "healthy", "latency_ms": duration_ms}
         except Exception as e:
-            return {
-                'status': 'unhealthy',
-                'error': str(e)
-            }
-    
+            return {"status": "unhealthy", "error": str(e)}
+
     def full_health_check(self) -> Dict[str, Any]:
         """Complete system health check"""
         return {
-            'timestamp': datetime.utcnow().isoformat(),
-            'sql': self.check_sql_health(),
-            'nosql': self.check_nosql_health(),
-            'cache': self.check_cache_health()
-        }
+            "timestamp": datetime.utcnow().isoformat(),
+            "sql": self.check_sql_health(),
+            "nosql": self.check_nosql_health(),
+            "cache": self.check_cache_health(),
+        }