altcodepro-polydb-python 2.5.9__py3-none-any.whl → 2.5.11__py3-none-any.whl

polydb/batch.py

@@ -2,8 +2,10 @@
 """
 Batch operations for high-throughput scenarios
 """
-from typing import List, Dict, Any, Optional, Union
+
 from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Union
+
 from .types import JsonDict
 
 
@@ -18,86 +20,76 @@ class BatchResult:
 
 class BatchOperations:
     """Batch CRUD operations"""
-    
+
     def __init__(self, factory):
         self.factory = factory
-    
+
     def bulk_insert(
         self,
         model: Union[type, str],
         records: List[JsonDict],
         *,
         chunk_size: int = 100,
-        fail_fast: bool = False
+        fail_fast: bool = False,
     ) -> BatchResult:
         """Bulk insert with chunking"""
         succeeded = []
         failed = []
-        
+
         for i in range(0, len(records), chunk_size):
-            chunk = records[i:i + chunk_size]
-            
+            chunk = records[i : i + chunk_size]
+
             for record in chunk:
                 try:
                     result = self.factory.create(model, record)
                     succeeded.append(result)
                 except Exception as e:
-                    failed.append({
-                        'data': record,
-                        'error': str(e)
-                    })
-                    
+                    failed.append({"data": record, "error": str(e)})
+
                     if fail_fast:
                         break
-        
+
         return BatchResult(
             succeeded=succeeded,
             failed=failed,
             total=len(records),
             success_count=len(succeeded),
-            error_count=len(failed)
+            error_count=len(failed),
         )
-    
+
     def bulk_update(
         self,
         model: Union[type, str],
         updates: List[Dict[str, Any]],  # {entity_id, data}
         *,
         chunk_size: int = 100,
-        fail_fast: bool = False
+        fail_fast: bool = False,
     ) -> BatchResult:
         """Bulk update"""
         succeeded = []
         failed = []
-        
+
         for i in range(0, len(updates), chunk_size):
-            chunk = updates[i:i + chunk_size]
-            
+            chunk = updates[i : i + chunk_size]
+
             for update in chunk:
                 try:
-                    result = self.factory.update(
-                        model,
-                        update['entity_id'],
-                        update['data']
-                    )
+                    result = self.factory.update(model, update["entity_id"], update["data"])
                     succeeded.append(result)
                 except Exception as e:
-                    failed.append({
-                        'data': update,
-                        'error': str(e)
-                    })
-                    
+                    failed.append({"data": update, "error": str(e)})
+
                     if fail_fast:
                         break
-        
+
         return BatchResult(
             succeeded=succeeded,
             failed=failed,
             total=len(updates),
             success_count=len(succeeded),
-            error_count=len(failed)
+            error_count=len(failed),
         )
-    
+
     def bulk_delete(
         self,
         model: Union[type, str],
@@ -105,59 +97,56 @@ class BatchOperations:
         *,
         chunk_size: int = 100,
         fail_fast: bool = False,
-        hard: bool = False
+        hard: bool = False,
     ) -> BatchResult:
         """Bulk delete"""
         succeeded = []
         failed = []
-        
+
         for i in range(0, len(entity_ids), chunk_size):
-            chunk = entity_ids[i:i + chunk_size]
-            
+            chunk = entity_ids[i : i + chunk_size]
+
             for entity_id in chunk:
                 try:
                     result = self.factory.delete(model, entity_id, hard=hard)
                     succeeded.append(result)
                 except Exception as e:
-                    failed.append({
-                        'data': {'entity_id': entity_id},
-                        'error': str(e)
-                    })
-                    
+                    failed.append({"data": {"entity_id": entity_id}, "error": str(e)})
+
                     if fail_fast:
                         break
-        
+
         return BatchResult(
             succeeded=succeeded,
             failed=failed,
             total=len(entity_ids),
             success_count=len(succeeded),
-            error_count=len(failed)
+            error_count=len(failed),
         )
 
 
 class TransactionManager:
     """Transaction support for SQL operations"""
-    
+
     def __init__(self, sql_adapter):
         self.sql = sql_adapter
-    
+
     def __enter__(self):
         self.conn = self.sql._get_connection()
         self.conn.autocommit = False
         return self
-    
+
     def __exit__(self, exc_type, exc_val, exc_tb):
         if exc_type is None:
             self.conn.commit()
         else:
             self.conn.rollback()
-        
+
         self.sql._return_connection(self.conn)
         return False
-    
+
     def execute(self, sql: str, params: Optional[List[Any]] = None):
         """Execute within transaction"""
         cursor = self.conn.cursor()
         cursor.execute(sql, params or [])
-        cursor.close()
+        cursor.close()

polydb/cache.py

@@ -2,12 +2,15 @@
 """
 Advanced caching with Redis support and strategies
 """
-from typing import Any, Dict, Optional, List
-import json
+
 import hashlib
+import json
 import threading
 from enum import Enum
+from typing import Any, Dict, List, Optional
+
 import redis
+
 from .json_safe import json_safe
 
 

polydb/cloudDatabaseFactory.py

@@ -4,7 +4,7 @@ import os
 import threading
 from typing import Dict, List, Optional
 
-from .base import SharedFilesAdapter
+from .errors import UnsupportedStorageTypeError
 
 # Deliberately NOT importing adapter classes at module level (they used to
 # be, redundantly -- every branch below already does its own lazy, local
@@ -27,7 +27,6 @@ from .models import (
     DynamoDBConfig,
     EFSFileConfig,
     FirestoreConfig,
-    GCPFileConfig,
     GCPPubSubConfig,
     GCPSecretManagerConfig,
     GCPStorageConfig,
@@ -115,11 +114,14 @@ class CloudDatabaseFactory:
         name: str = "azure",
         container_name: Optional[str] = None,
     ) -> (
-        AzureBlobStorageAdapter
-        | S3CompatibleAdapter
-        | GCPStorageAdapter
-        | VercelBlobAdapter
-        | BlockchainBlobAdapter
+        # noqa: F821 -- deliberately never imported at module level (see
+        # this file's own top comment); real only under `from __future__
+        # import annotations`, which this module has.
+        AzureBlobStorageAdapter  # noqa: F821
+        | S3CompatibleAdapter  # noqa: F821
+        | GCPStorageAdapter  # noqa: F821
+        | VercelBlobAdapter  # noqa: F821
+        | BlockchainBlobAdapter  # noqa: F821
     ):
         with self._lock:
             # cache per (name, container) so different containers don't collide
@@ -223,9 +225,16 @@ class CloudDatabaseFactory:
         partition_config: Optional[PartitionConfig] = None,
         name: str = "kv",
     ):
+        # Cache per (name, partition_config) -- two calls with the same `name`
+        # but different partition configs used to silently share the first
+        # adapter built, with the second caller's partition_config thrown
+        # away. Mirrors the object::/secrets:: composite-key pattern used
+        # elsewhere in this file.
+        cache_key = f"kv::{name}::{self._partition_config_key(partition_config)}"
+
         with self._lock:
-            if name in self.instances:
-                return self.instances[name]
+            if cache_key in self.instances:
+                return self.instances[cache_key]
 
             cfg = self.configs.get(name)
             if not cfg:
@@ -240,7 +249,6 @@ class CloudDatabaseFactory:
 
                 if isinstance(cfg, AzureTableConfig):
                     connection_string = cfg.connection_string or ""
-                    table_name = cfg.table_name
                     container_name = cfg.container_name
 
                 instance = AzureTableStorageAdapter(
@@ -335,7 +343,7 @@ class CloudDatabaseFactory:
                 )
 
             # ---------------- MONGODB ----------------
-            else:
+            elif cfg.provider == CloudProvider.MONGODB:
                 from .adapters.MongoDBAdapter import MongoDBAdapter
 
                 mongo_uri = ""
@@ -351,19 +359,50 @@ class CloudDatabaseFactory:
                     db_name=db_name,
                 )
 
-            self.instances[name] = instance
+            # ---------------- NO REAL KV BACKEND FOR THIS PROVIDER ----------
+            # Providers like POSTGRESQL / S3_COMPATIBLE / VAULT / KAFKA /
+            # RABBITMQ have no NoSQL KV adapter of their own. This branch
+            # used to be a bare `else -> MongoDBAdapter("", "")`, which built
+            # a Mongo client pointed at an empty URI and failed obscurely on
+            # first real use instead of here, at construction time, with a
+            # message naming the actual problem.
+            else:
+                raise UnsupportedStorageTypeError(
+                    f"get_nosql_kv: provider {cfg.provider.value!r} has no NoSQL KV adapter. "
+                    "Register an explicit StorageConfig for a supported KV provider "
+                    "(azure, aws, gcp, vercel, mongodb, blockchain) under this `name`, "
+                    "or use get_sql() for a PostgreSQL-only model."
+                )
+
+            self.instances[cache_key] = instance
             return instance
 
+    @staticmethod
+    def _partition_config_key(partition_config: Optional[PartitionConfig]) -> str:
+        """Stable string identity for a PartitionConfig, for use in a cache key."""
+        if partition_config is None:
+            return ""
+        return "|".join(
+            [
+                partition_config.partition_key_template,
+                partition_config.row_key_template or "",
+                ",".join(partition_config.composite_keys or []),
+                str(partition_config.auto_generate),
+            ]
+        )
+
     def get_queue(
         self, name="azure_queue"
     ) -> (
-        AzureQueueAdapter
-        | SQSAdapter
-        | GCPPubSubAdapter
-        | VercelQueueAdapter
-        | BlockchainQueueAdapter
-        | KafkaQueueAdapter
-        | RabbitMQAdapter
+        # noqa: F821 -- same deliberate not-imported-at-module-level
+        # pattern as get_object_storage's own return annotation above.
+        AzureQueueAdapter  # noqa: F821
+        | SQSAdapter  # noqa: F821
+        | GCPPubSubAdapter  # noqa: F821
+        | VercelQueueAdapter  # noqa: F821
+        | BlockchainQueueAdapter  # noqa: F821
+        | KafkaQueueAdapter  # noqa: F821
+        | RabbitMQAdapter  # noqa: F821
     ):
         with self._lock:
             if name in self.instances:
@@ -598,9 +637,7 @@ class CloudDatabaseFactory:
                 url, token, mount_point = None, None, "secret"
                 if isinstance(cfg, VaultConfig):
                     url, token, mount_point = cfg.url, cfg.token, cfg.mount_point
-                instance = VaultAdapter(
-                    url=url or "", token=token or "", mount_point=mount_point
-                )
+                instance = VaultAdapter(url=url or "", token=token or "", mount_point=mount_point)
 
             self.instances[cache_key] = instance
             return instance

polydb/databaseFactory.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 
 import logging
 import os
+import re as _re
 from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
@@ -21,21 +22,18 @@ from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
 from tenacity import retry, stop_after_attempt, wait_exponential
 
 from .adapters.PostgreSQLAdapter import PostgreSQLAdapter
-
+from .audit.context import AuditContext
+from .audit.manager import AuditManager
 from .base.NoSQLKVAdapter import NoSQLKVAdapter
-
 from .batch import BatchOperations
 from .cache import CacheWarmer, RedisCacheEngine
+from .cloudDatabaseFactory import CloudDatabaseFactory
+from .errors import AdapterConfigurationError
+from .models import PageRequest, PageResult
 from .monitoring import HealthCheck, MetricsCollector, PerformanceMonitor
+from .query import QueryBuilder
 from .security import DataMasking, FieldEncryption
-from .errors import AdapterConfigurationError
 from .types import JsonDict, Lookup, ModelMeta
-from .audit.manager import AuditManager
-from .audit.context import AuditContext
-from .query import Operator, QueryBuilder
-from .cloudDatabaseFactory import CloudDatabaseFactory
-from .models import PageRequest, PageResult
-import re as _re
 
 logger = logging.getLogger(__name__)
 
@@ -382,7 +380,6 @@ class DatabaseFactory:
         adapters = self._adapters_for(model, meta, engine_override)
         after_plain = None
         success = False
-        error: Optional[str] = None
         entity_id: Optional[Any] = None
 
         def _op() -> JsonDict:
@@ -559,7 +556,6 @@ class DatabaseFactory:
         )
         after_plain = None
         success = False
-        error: Optional[str] = None
 
         def _op() -> JsonDict:
             nonlocal after_plain, success
@@ -687,7 +683,6 @@ class DatabaseFactory:
         adapters = self._adapters_for(model, meta, engine_override)
         after_plain = None
         success = False
-        error: Optional[str] = None
 
         def _op() -> JsonDict:
             nonlocal after_plain, success
@@ -763,7 +758,6 @@ class DatabaseFactory:
             session_vars=session_vars,
         )
         success = False
-        error: Optional[str] = None
 
         def _op() -> JsonDict:
             nonlocal success

polydb/errors.py

@@ -2,6 +2,7 @@
 """
 Structured exceptions for cloud database operations
 """
+
 from __future__ import annotations
 
 
@@ -52,6 +53,7 @@ class ValidationError(CloudDBError):
 
     pass
 
+
 class PolyDBError(Exception):
     """Base exception for polydb."""
 

polydb/json_safe.py

@@ -1,8 +1,7 @@
-import json
 from datetime import datetime
 
+
 def json_safe(obj):
     if isinstance(obj, datetime):
         return obj.isoformat()
     return str(obj)
-

polydb/models.py

@@ -4,8 +4,8 @@ Data models and configurations
 """
 
 from dataclasses import dataclass, field
-from typing import Optional, List, Callable, Any, Dict
 from enum import Enum
+from typing import Any, Callable, Dict, List, Optional
 
 
 class CloudProvider(Enum):

polydb/monitoring.py

@@ -2,13 +2,13 @@
 """
 Comprehensive monitoring, metrics, and observability
 """
-from typing import Dict, Any, Optional, List, Callable
-from dataclasses import dataclass, field
-from datetime import datetime, timedelta
-from collections import defaultdict
+
+import logging
 import threading
 import time
-import logging
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from typing import Any, Callable, Dict, List, Optional
 
 
 @dataclass
@@ -154,25 +154,25 @@ class MetricsCollector:
         agg = self.aggregate()
 
         lines = [
-            f"# HELP polydb_queries_total Total number of queries",
-            f"# TYPE polydb_queries_total counter",
+            "# HELP polydb_queries_total Total number of queries",
+            "# TYPE polydb_queries_total counter",
             f"polydb_queries_total {agg.total_queries}",
             "",
-            f"# HELP polydb_queries_successful Successful queries",
-            f"# TYPE polydb_queries_successful counter",
+            "# HELP polydb_queries_successful Successful queries",
+            "# TYPE polydb_queries_successful counter",
             f"polydb_queries_successful {agg.successful_queries}",
             "",
-            f"# HELP polydb_queries_failed Failed queries",
-            f"# TYPE polydb_queries_failed counter",
+            "# HELP polydb_queries_failed Failed queries",
+            "# TYPE polydb_queries_failed counter",
             f"polydb_queries_failed {agg.failed_queries}",
             "",
-            f"# HELP polydb_query_duration_ms Query duration",
-            f"# TYPE polydb_query_duration_ms summary",
+            "# HELP polydb_query_duration_ms Query duration",
+            "# TYPE polydb_query_duration_ms summary",
             f"polydb_query_duration_ms_sum {agg.total_duration_ms}",
             f"polydb_query_duration_ms_count {agg.total_queries}",
             "",
-            f"# HELP polydb_cache_hit_rate Cache hit rate",
-            f"# TYPE polydb_cache_hit_rate gauge",
+            "# HELP polydb_cache_hit_rate Cache hit rate",
+            "# TYPE polydb_cache_hit_rate gauge",
             f"polydb_cache_hit_rate {agg.cache_hit_rate}",
         ]
 
@@ -284,6 +284,18 @@ class HealthCheck:
             retrieved = self.factory._cache.get(test_key, {})
             duration_ms = (time.perf_counter() - start) * 1000
 
+            # A real, found-by-adding-CI-lint gap: `retrieved` was read
+            # back and then never actually checked against what was
+            # written -- set()/get() not raising is not the same thing as
+            # the cache round-tripping the value correctly, so a cache
+            # silently returning stale/empty/wrong data still reported
+            # "healthy" here as long as neither call raised.
+            if retrieved != test_value:
+                return {
+                    "status": "unhealthy",
+                    "error": f"cache round-trip mismatch: wrote {test_value!r}, read back {retrieved!r}",
+                }
+
             return {"status": "healthy", "latency_ms": duration_ms}
         except Exception as e:
             return {"status": "unhealthy", "error": str(e)}