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

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

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

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

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

@@ -283,11 +283,22 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
 
         return out
 
+    def _sanitize_blob_part(self, value: str) -> str:
+        # Blob-safe: lowercase, alphanumeric + dash only
+        s = str(value).lower()
+        s = re.sub(r"[^a-z0-9\-]", "-", s)
+        s = re.sub(r"-+", "-", s)
+        return s.strip("-")[:100]
+
     def _entity_size_bytes(self, entity: JsonDict) -> int:
         return len(json.dumps(entity, default=json_safe).encode("utf-8"))
 
     def _blob_key(self, pk: str, rk: str, checksum: str) -> str:
-        return f"{pk}/{rk}/{checksum}.json"
+        safe_pk = self._sanitize_blob_part(pk)
+        safe_rk = self._sanitize_blob_part(rk)
+
+        # Flat structure (avoid deep paths)
+        return f"{safe_pk}-{safe_rk}-{checksum}.json"
 
     def _blob_upload(self, blob_key: str, data_bytes: bytes):
         if not self._blob_service:
@@ -325,27 +336,52 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
 
             entity = self._pack_entity(model, safe_pk, safe_rk, data)
 
-            # === Check for any dangerously large property (64KB limit) ===
+            # ---------------------------------------------------
+            # SIZE ESTIMATION (Azure uses UTF-16 for strings)
+            # ---------------------------------------------------
+            MAX_PROPERTY_CHARS = 30 * 1024  # ~30K chars safe under 32K limit
+            MAX_ENTITY_SIZE = 40 * 1024  # conservative total entity 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
+
             for key, value in entity.items():
-                if (
-                    isinstance(value, str) and len(value.encode("utf-8")) > 60 * 1024
-                ):  # 60KB safe margin
+                if _is_large_string(value):
                     has_large_property = True
-                    logger.info(
-                        f"Large property detected: {key} ({len(value.encode('utf-8'))//1024} KB) → overflowing to Blob"
+                    large_key = key
+                    logger.warning(
+                        f"LARGE PROPERTY DETECTED: {key} length={len(value)} chars → forcing blob overflow"
                     )
                     break
 
-            if has_large_property or self._entity_size_bytes(entity) > self.AZURE_TABLE_MAX_SIZE:
-                # Force full overflow to Blob
-                full_payload_bytes = json.dumps(entity, default=json_safe).encode("utf-8")
+            # Check full entity size
+            entity_json = json.dumps(entity, default=json_safe)
+            entity_size = len(entity_json.encode("utf-8"))
+
+            force_blob = has_large_property or entity_size > MAX_ENTITY_SIZE
+
+            if force_blob:
+                logger.info(
+                    f"Entity exceeds safe limits → using blob storage "
+                    f"(size={entity_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()
                 blob_key = self._blob_key(safe_pk, safe_rk, checksum)
 
                 self._blob_upload(blob_key, full_payload_bytes)
 
-                # Create small reference record for Table
+                # ---------------------------------------------------
+                # STORE REFERENCE IN TABLE
+                # ---------------------------------------------------
                 reference_entity = {
                     "PartitionKey": safe_pk,
                     "RowKey": safe_rk,
@@ -357,33 +393,49 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
                     "__keymap__": entity.get("__keymap__", "{}"),
                 }
 
-                # Keep a few small scalar fields for basic queries
+                # Keep only small searchable fields
                 for k, v in entity.items():
                     if k in ("PartitionKey", "RowKey", "__keymap__", _MODEL_FIELD):
                         continue
                     if k.startswith("_"):
                         continue
-                    if (
-                        v is None
-                        or isinstance(v, (str, bool, int, float, datetime))
-                        and len(str(v)) < 1000
-                    ):
+
+                    if isinstance(v, (str, bool, int, float)):
+                        if isinstance(v, str) and len(v) > 2000:
+                            continue
+                        reference_entity[k] = v
+
+                    elif isinstance(v, datetime):
                         reference_entity[k] = v
 
                 self._table_client.upsert_entity(reference_entity)
-                logger.info(f"Entity overflowed to Blob: {blob_key}")
+
+                logger.info(f"Stored in blob: {blob_key} ({len(full_payload_bytes)//1024} KB)")
+
                 return {
                     "PartitionKey": safe_pk,
                     "RowKey": safe_rk,
                     "_overflow": True,
+                    "_blob_key": blob_key,
                     "id": safe_rk,
                 }
 
-            # Normal small entity
+            # ---------------------------------------------------
+            # NORMAL TABLE STORAGE
+            # ---------------------------------------------------
             self._table_client.upsert_entity(entity)
-            return {"PartitionKey": safe_pk, "RowKey": safe_rk, "id": safe_rk}
+
+            return {
+                "PartitionKey": safe_pk,
+                "RowKey": safe_rk,
+                "id": safe_rk,
+            }
 
         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
+
             raise NoSQLError(f"Azure Table put failed: {str(e)}")
 
     @retry(max_attempts=3, delay=1.0, exceptions=(NoSQLError,))
@@ -417,6 +469,9 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
 
                 restored = json.loads(blob_data.decode("utf-8"))
                 out = self._unpack_entity(restored)
+                out["_overflow"] = True
+                out["_blob_key"] = blob_key
+                out["_checksum"] = checksum
                 if "id" not in out:
                     out["id"] = safe_rk
                 return out
@@ -489,10 +544,19 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
 
                 if ent_dict.get("_overflow"):
                     blob_key = ent_dict.get("_blob_key")
+                    checksum = ent_dict.get("_checksum")
                     if blob_key:
-                        blob_data = self._blob_download(blob_key)
-                        restored = json.loads(blob_data.decode("utf-8"))
-                        out = self._unpack_entity(restored)
+                        try:
+                            blob_data = self._blob_download(blob_key)
+                            actual_checksum = hashlib.md5(blob_data).hexdigest()
+                            if checksum and actual_checksum != checksum:
+                                raise NoSQLError("Checksum mismatch")
+
+                            restored = json.loads(blob_data.decode("utf-8"))
+                            out = self._unpack_entity(restored)
+                        except Exception as e:
+                            logger.error(f"Blob read failed, falling back to table: {e}")
+                            out = self._unpack_entity(ent_dict)
                     else:
                         out = self._unpack_entity(ent_dict)
                 else: