altcodepro-polydb-python 2.3.2__py3-none-any.whl → 2.3.4__py3-none-any.whl

{altcodepro_polydb_python-2.3.2.dist-info → altcodepro_polydb_python-2.3.4.dist-info}/METADATA

@@ -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.dist-info → altcodepro_polydb_python-2.3.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-altcodepro_polydb_python-2.3.2.dist-info/licenses/LICENSE,sha256=9X8GLocsBwy-5aR5JGOt2SAMDDPs9Qv-YnqmHBHOXrw,1067
+altcodepro_polydb_python-2.3.4.dist-info/licenses/LICENSE,sha256=9X8GLocsBwy-5aR5JGOt2SAMDDPs9Qv-YnqmHBHOXrw,1067
 polydb/PolyDB.py,sha256=p9eDdvBGosE4fNSSAbtq3tHObdKZ-C2V2Q_ia39Ackk,23397
 polydb/__init__.py,sha256=UhUzfSvmMgKbV2tSME1ooIyfshIBi7_WyU4xl1tWWiA,1454
 polydb/advanced_query.py,sha256=cxMB-EB-qT3bWXJlhmjnMCUtrzogORWyoEfS50Dy7go,4280
@@ -24,7 +24,7 @@ polydb/validation.py,sha256=a1o1d02k3c6PWQwkBbw_0nEmIgrdB5RR8OcpNQMn4cA,4810
 polydb/adapters/AzureBlobStorageAdapter.py,sha256=iNscCIeoWy4YJo3IbI7gNam-NUT7t45ayrlPnYfqlCQ,6409
 polydb/adapters/AzureFileStorageAdapter.py,sha256=OuZY5P-FTQ36954obJN65oSMqmW3d-7QBmXxVGX0lds,6086
 polydb/adapters/AzureQueueAdapter.py,sha256=5tslwI0DgvMeb20w57aVSSSKiuCJEKrYjN0kGuFcdUI,5276
-polydb/adapters/AzureTableStorageAdapter.py,sha256=Vm-D769VLeaWtGYluAWt1gXehckn7n9V8XQmu-_avdU,19296
+polydb/adapters/AzureTableStorageAdapter.py,sha256=wc_EcrwZmc5M6321Y6tio1BYiPEtJIck9gu6BqQDMsY,21890
 polydb/adapters/BlockchainBlobAdapter.py,sha256=BXSDT6rDGGE04qM2-dVNAeWk-VcF82JGHAdUJeYHCbI,3320
 polydb/adapters/BlockchainKVAdapter.py,sha256=5Egic8QyulgYcy9O12iWKq2EDyVEvnXp_ereYgIvbHk,4546
 polydb/adapters/BlockchainQueueAdapter.py,sha256=K01klT8Eu8c-y1G9Sg2r0PIjay_at9x27kCTTEHPkNY,4179
@@ -52,7 +52,7 @@ polydb/base/ObjectStorageAdapter.py,sha256=mNdJnhoB3VqSCQvmcoel5PohrVQw7Nrajdd5s
 polydb/base/QueueAdapter.py,sha256=jFgyG-SUK4nhRNxm2NbzUbwnA9b_5iAC-ikLSUpXRwk,799
 polydb/base/SharedFilesAdapter.py,sha256=hvmdNNhNxpN46Ob9RLAi8l46GB6JolYyZWnAMuaJ86g,708
 polydb/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-altcodepro_polydb_python-2.3.2.dist-info/METADATA,sha256=9FRHXZeQilTQpyTuZQNTikb563gty04s8VUGc0cQJAU,11910
-altcodepro_polydb_python-2.3.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-altcodepro_polydb_python-2.3.2.dist-info/top_level.txt,sha256=WgLFWJoYjUhwvyPxJFl6jYLrVFuBJDX3OABf4ocwk_E,7
-altcodepro_polydb_python-2.3.2.dist-info/RECORD,,
+altcodepro_polydb_python-2.3.4.dist-info/METADATA,sha256=lbV1IUtpKJ34lC4ViBv1RNcpLk8IPujTe6eU6HO-tnY,11910
+altcodepro_polydb_python-2.3.4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+altcodepro_polydb_python-2.3.4.dist-info/top_level.txt,sha256=WgLFWJoYjUhwvyPxJFl6jYLrVFuBJDX3OABf4ocwk_E,7
+altcodepro_polydb_python-2.3.4.dist-info/RECORD,,

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: