altcodepro-polydb-python 2.3.4__tar.gz → 2.3.6__tar.gz

{altcodepro_polydb_python-2.3.4/src/altcodepro_polydb_python.egg-info → altcodepro_polydb_python-2.3.6}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "altcodepro-polydb-python"
-version = "2.3.4"
+version = "2.3.6"
 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.11"

{altcodepro_polydb_python-2.3.4 → altcodepro_polydb_python-2.3.6/src/altcodepro_polydb_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.3.4
+Version: 2.3.6
 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.3.4 → altcodepro_polydb_python-2.3.6}/src/polydb/adapters/AzureTableStorageAdapter.py

@@ -49,7 +49,6 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
         self,
         partition_config: Optional[PartitionConfig] = None,
         connection_string: str = "",
-        table_name="",
         container_name="",
     ):
         super().__init__(partition_config)
@@ -57,14 +56,12 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
         self.connection_string = (
             connection_string or os.getenv("AZURE_STORAGE_CONNECTION_STRING") or ""
         )
-        self.table_name = table_name or os.getenv("AZURE_TABLE_NAME", "defaulttable") or ""
         self.container_name = container_name or os.getenv("AZURE_CONTAINER_NAME", "overflow") or ""
 
         if not self.connection_string:
             raise ConnectionError("AZURE_STORAGE_CONNECTION_STRING must be set")
 
-        self._client = None
-        self._table_client = None
+        self._client: Any = None
         self._blob_service = None
         self._client_lock = threading.Lock()
         self._initialize_client()
@@ -77,13 +74,6 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
             with self._client_lock:
                 if not self._client:
                     self._client = TableServiceClient.from_connection_string(self.connection_string)
-                    self._table_client = self._client.get_table_client(self.table_name)
-
-                    try:
-                        self._client.create_table_if_not_exists(self.table_name)
-                    except Exception:
-                        pass
-
                     self._blob_service = BlobServiceClient.from_connection_string(
                         self.connection_string
                     )
@@ -213,7 +203,6 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
     def _pack_entity(self, model: type, pk: str, rk: str, data: JsonDict) -> JsonDict:
         entity: JsonDict = {"PartitionKey": pk, "RowKey": rk}
 
-        # ✅ model isolation
         entity[_MODEL_FIELD] = model.__qualname__
 
         keymap: Dict[str, str] = {}
@@ -324,28 +313,86 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
     # -----------------------------
     # Required NoSQLKVAdapter hooks
     # -----------------------------
+    def _sanitize_table_name(self, name: str) -> str:
+        """Convert collection_name to valid Azure Table name (alphanumeric only)."""
+        if not name:
+            return "defaulttable"
+
+        # Remove all invalid characters, keep only letters and numbers
+        sanitized = re.sub(r"[^a-zA-Z0-9]", "", name)
+
+        # Must start with a letter
+        if sanitized and sanitized[0].isdigit():
+            sanitized = "t" + sanitized
+
+        # Must be 3-63 characters
+        if len(sanitized) < 3:
+            sanitized = sanitized + "table"
+        if len(sanitized) > 63:
+            sanitized = sanitized[:63]
+
+        return sanitized.lower()
+
+    def _get_table_name(self, model: type) -> str:
+        """
+        Extract collection_name from UDL model definition.
+        """
+        # Primary source: UDL definition
+        definition = getattr(model, "__udl_definition__", None)
+        if definition:
+            metadata = getattr(definition, "x_metadata", {}) or {}
+            collection_name = metadata.get("collection_name")
+            if collection_name:
+                return self._sanitize_table_name(collection_name)
+
+        # Fallback: __polydb__ metadata
+        polydb_meta = getattr(model, "__polydb__", None)
+        if isinstance(polydb_meta, dict):
+            collection = polydb_meta.get("collection") or polydb_meta.get("collection_name")
+            if collection:
+                return self._sanitize_table_name(str(collection))
+
+        # Last resort
+        return os.getenv("AZURE_TABLE_NAME", "defaulttable") or "defaulttable"
+
+    def _get_table_client(self, model: type):
+        """
+        Get table client + automatically create the table if it doesn't exist.
+        This is the recommended pattern for Azure Table Storage.
+        """
+        table_name = self._get_table_name(model)
+
+        try:
+            # This is the key call - creates the table if missing
+            self._client.create_table_if_not_exists(table_name)
+            logger.info(f"✅ Azure Table ensured/created: {table_name}")
+        except Exception as e:
+            # TableAlreadyExists is normal and safe to ignore
+            if "TableAlreadyExists" not in str(e) and "already exists" not in str(e).lower():
+                logger.warning(f"Could not create table {table_name}: {e}")
+
+        # Now return the client
+        return self._client.get_table_client(table_name=table_name)
 
     @retry(max_attempts=3, delay=1.0, exceptions=(NoSQLError,))
     def _put_raw(self, model: type, pk: str, rk: str, data: JsonDict) -> JsonDict:
         try:
-            if not self._table_client:
-                raise NoSQLError("Azure Table client not initialized")
-
+            self._table_client = self._get_table_client(model)
             safe_pk = self._sanitize_pk_rk(pk)
             safe_rk = self._sanitize_pk_rk(rk)
 
+            # Pack entity (encoded for Azure Table)
             entity = self._pack_entity(model, safe_pk, safe_rk, data)
 
             # ---------------------------------------------------
-            # SIZE ESTIMATION (Azure uses UTF-16 for strings)
+            # SIZE ESTIMATION (use ORIGINAL payload, not packed)
             # ---------------------------------------------------
-            MAX_PROPERTY_CHARS = 30 * 1024  # ~30K chars safe under 32K limit
-            MAX_ENTITY_SIZE = 40 * 1024  # conservative total entity threshold
+            MAX_PROPERTY_CHARS = 30 * 1024  # ~30K safe under UTF-16 32K limit
+            MAX_ENTITY_SIZE = 40 * 1024  # conservative total threshold
 
             def _is_large_string(val: Any) -> bool:
                 return isinstance(val, str) and len(val) > MAX_PROPERTY_CHARS
 
-            # Check if any property exceeds safe char limit
             has_large_property = False
             large_key = None
 
@@ -358,42 +405,40 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
                     )
                     break
 
-            # Check full entity size
-            entity_json = json.dumps(entity, default=json_safe)
-            entity_size = len(entity_json.encode("utf-8"))
+            payload_json = json.dumps(data, default=json_safe)
+            payload_bytes = payload_json.encode("utf-8")
+            payload_size = len(payload_bytes)
 
-            force_blob = has_large_property or entity_size > MAX_ENTITY_SIZE
+            force_blob = has_large_property or payload_size > MAX_ENTITY_SIZE
 
+            # ---------------------------------------------------
+            # BLOB OVERFLOW PATH
+            # ---------------------------------------------------
             if force_blob:
                 logger.info(
                     f"Entity exceeds safe limits → using blob storage "
-                    f"(size={entity_size//1024} KB, large_key={large_key})"
+                    f"(size={payload_size // 1024} KB, large_key={large_key})"
                 )
 
-                # ---------------------------------------------------
-                # STORE FULL ENTITY IN BLOB
-                # ---------------------------------------------------
-                full_payload_bytes = entity_json.encode("utf-8")
-                checksum = hashlib.md5(full_payload_bytes).hexdigest()
+                checksum = hashlib.md5(payload_bytes).hexdigest()
                 blob_key = self._blob_key(safe_pk, safe_rk, checksum)
 
-                self._blob_upload(blob_key, full_payload_bytes)
+                # Upload ORIGINAL payload (not packed entity)
+                self._blob_upload(blob_key, payload_bytes)
 
-                # ---------------------------------------------------
-                # STORE REFERENCE IN TABLE
-                # ---------------------------------------------------
+                # Build reference entity
                 reference_entity = {
                     "PartitionKey": safe_pk,
                     "RowKey": safe_rk,
                     _MODEL_FIELD: model.__qualname__,
                     "_overflow": True,
                     "_blob_key": blob_key,
-                    "_size": len(full_payload_bytes),
+                    "_size": payload_size,
                     "_checksum": checksum,
                     "__keymap__": entity.get("__keymap__", "{}"),
                 }
 
-                # Keep only small searchable fields
+                # Keep only small queryable fields
                 for k, v in entity.items():
                     if k in ("PartitionKey", "RowKey", "__keymap__", _MODEL_FIELD):
                         continue
@@ -407,32 +452,31 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
 
                     elif isinstance(v, datetime):
                         reference_entity[k] = v
-
+                self._table_client = self._get_table_client(model)
                 self._table_client.upsert_entity(reference_entity)
 
-                logger.info(f"Stored in blob: {blob_key} ({len(full_payload_bytes)//1024} KB)")
+                logger.info(f"Stored in blob: {blob_key} ({payload_size // 1024} KB)")
 
-                return {
-                    "PartitionKey": safe_pk,
-                    "RowKey": safe_rk,
-                    "_overflow": True,
-                    "_blob_key": blob_key,
-                    "id": safe_rk,
-                }
+                restored = self._unpack_entity(entity)
+                restored["_overflow"] = True
+                restored["_blob_key"] = blob_key
+                restored["_checksum"] = checksum
+                restored["_size"] = payload_size
+                restored["id"] = safe_rk
+
+                return restored
 
             # ---------------------------------------------------
             # NORMAL TABLE STORAGE
             # ---------------------------------------------------
             self._table_client.upsert_entity(entity)
 
-            return {
-                "PartitionKey": safe_pk,
-                "RowKey": safe_rk,
-                "id": safe_rk,
-            }
+            restored = self._unpack_entity(entity)
+            restored["id"] = safe_rk
+
+            return restored
 
         except Exception as e:
-            # Do NOT retry deterministic size errors
             if "PropertyValueTooLarge" in str(e):
                 raise NoSQLError("Azure Table limit exceeded → must use blob overflow") from e
 
@@ -441,12 +485,9 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
     @retry(max_attempts=3, delay=1.0, exceptions=(NoSQLError,))
     def _get_raw(self, model: type, pk: str, rk: str) -> Optional[JsonDict]:
         try:
-            if not self._table_client:
-                return None
-
             safe_pk = self._sanitize_pk_rk(pk)
             safe_rk = self._sanitize_pk_rk(rk)
-
+            self._table_client = self._get_table_client(model)
             entity = self._table_client.get_entity(safe_pk, safe_rk)
             entity_dict = dict(entity)
 
@@ -491,9 +532,7 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
         self, model: type, filters: Dict[str, Any], limit: Optional[int]
     ) -> List[JsonDict]:
         try:
-            if not self._table_client:
-                return []
-
+            self._table_client = self._get_table_client(model)
             # always enforce model filter
             eff_filters = dict(filters or {})
             eff_filters[_MODEL_FIELD] = model.__qualname__
@@ -580,9 +619,7 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
     @retry(max_attempts=3, delay=1.0, exceptions=(NoSQLError,))
     def _delete_raw(self, model: type, pk: str, rk: str, etag: Optional[str]) -> JsonDict:
         try:
-            if not self._table_client:
-                return {"deleted": False}
-
+            self._table_client = self._get_table_client(model)
             safe_pk = self._sanitize_pk_rk(pk)
             safe_rk = self._sanitize_pk_rk(rk)
 

{altcodepro_polydb_python-2.3.4 → altcodepro_polydb_python-2.3.6}/src/polydb/base/NoSQLKVAdapter.py

@@ -36,8 +36,8 @@ class NoSQLKVAdapter:
     def _get_pk_rk(self, model: type, data: JsonDict) -> Tuple[str, str]:
         """Extract PK/RK from model metadata"""
         meta = getattr(model, "__polydb__", {})
-        pk_field = meta.get("pk_field", "id")
-        rk_field = meta.get("rk_field")
+        pk_field = meta.get("pk_field") or  meta.get("partition_key", "tenant_id")
+        rk_field = meta.get("rk_field") or  meta.get("sort_key", "id")
 
         if self.partition_config:
             try:
@@ -257,6 +257,7 @@ class NoSQLKVAdapter:
         if isinstance(entity_id, dict):
             pk = entity_id.get("partition_key") or entity_id.get("pk")
             rk = entity_id.get("row_key") or entity_id.get("rk") or entity_id.get("id")
+            
         else:
             pk, rk = self._get_pk_rk(model, {"id": entity_id})
 

{altcodepro_polydb_python-2.3.4 → altcodepro_polydb_python-2.3.6}/src/polydb/cloudDatabaseFactory.py

@@ -234,7 +234,6 @@ class CloudDatabaseFactory:
                 from .adapters.AzureTableStorageAdapter import AzureTableStorageAdapter
 
                 connection_string = ""
-                table_name = ""
                 container_name = ""
 
                 if isinstance(cfg, AzureTableConfig):
@@ -245,7 +244,6 @@ class CloudDatabaseFactory:
                 instance = AzureTableStorageAdapter(
                     partition_config=partition_config,
                     connection_string=connection_string,
-                    table_name=table_name,
                     container_name=container_name,
                 )
 

{altcodepro_polydb_python-2.3.4 → altcodepro_polydb_python-2.3.6}/src/polydb/databaseFactory.py

@@ -20,6 +20,10 @@ 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 .base.NoSQLKVAdapter import NoSQLKVAdapter
+
 from .batch import BatchOperations
 from .cache import CacheWarmer, RedisCacheEngine
 from .monitoring import HealthCheck, MetricsCollector, PerformanceMonitor
@@ -81,8 +85,8 @@ class EngineOverride:
 
 @dataclass
 class _ResolvedAdapters:
-    sql: Any
-    nosql: Any
+    sql: PostgreSQLAdapter
+    nosql: NoSQLKVAdapter
     engine_name: str
 
 
@@ -281,14 +285,14 @@ class DatabaseFactory:
         return self._engine_by_name[name]
 
     @property
-    def _sql(self) -> Any:
+    def _sql(self) -> PostgreSQLAdapter:
         for e in self._engines:
             if e.is_default_sql:
                 return e.sql()
         return self._engines[0].sql()
 
     @property
-    def _nosql(self) -> Any:
+    def _nosql(self) -> NoSQLKVAdapter:
         for e in self._engines:
             if e.is_default_nosql:
                 return e.nosql()