altcodepro-polydb-python 2.3.26__py3-none-any.whl → 2.3.28__py3-none-any.whl

{altcodepro_polydb_python-2.3.26.dist-info → altcodepro_polydb_python-2.3.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.3.26
+Version: 2.3.28
 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.26.dist-info → altcodepro_polydb_python-2.3.28.dist-info}/RECORD

@@ -1,11 +1,11 @@
-altcodepro_polydb_python-2.3.26.dist-info/licenses/LICENSE,sha256=9X8GLocsBwy-5aR5JGOt2SAMDDPs9Qv-YnqmHBHOXrw,1067
+altcodepro_polydb_python-2.3.28.dist-info/licenses/LICENSE,sha256=9X8GLocsBwy-5aR5JGOt2SAMDDPs9Qv-YnqmHBHOXrw,1067
 polydb/PolyDB.py,sha256=MG7-nV59zDvrUQwXNEgV4eetHCeW9TYY9DQqtxu_r7k,23543
 polydb/__init__.py,sha256=d9KSz888A336904TPEjWPYBtyJLPB0lTdcaOnYp8byY,1535
 polydb/advanced_query.py,sha256=cxMB-EB-qT3bWXJlhmjnMCUtrzogORWyoEfS50Dy7go,4280
 polydb/batch.py,sha256=_DjWZa1ZXYSk6MLKqFe0eT7SYVRZtYNqZb9bI8Y2sao,4566
 polydb/cache.py,sha256=JBXF1XEK-fY80ar8SDE893Z1Z116YtXAEG0PaJ0Nkcw,7658
 polydb/cloudDatabaseFactory.py,sha256=Gp6L__YtgrkGahD8B7ItzXMHCoj2ZUGDjXLS9w0TujY,17780
-polydb/databaseFactory.py,sha256=uBzX7K-k_aFHLQyFemy3XIe3lsOjAvjRFfaC6phITlA,41470
+polydb/databaseFactory.py,sha256=AdEMRtWcwf0elJ9JhrWS5krre-3RVFfIgt0mA93eJJQ,44068
 polydb/decorators.py,sha256=L_WP2uXP_k8Ac49SUm-mthbM4jWI-XYfHXEyKzumOww,43062
 polydb/errors.py,sha256=jF_55fbfg6b6mBc116dzU_uBG9qiIKbr5jvmDuJx-Jw,1573
 polydb/json_safe.py,sha256=R5PrqAGirqjYKPyy-8KH-lSXjLH0FPr2TSGozy4eheU,149
@@ -23,8 +23,8 @@ polydb/utils.py,sha256=tS_KI1vt-VZ6JftbFxbnVxC0xpie1-zYikTGf1nSoFw,3183
 polydb/validation.py,sha256=a1o1d02k3c6PWQwkBbw_0nEmIgrdB5RR8OcpNQMn4cA,4810
 polydb/adapters/AzureBlobStorageAdapter.py,sha256=4vD55Z8DBTzBK66jIJbo5bNMY-AQ61MlP0-P2Fv_JgQ,7083
 polydb/adapters/AzureFileStorageAdapter.py,sha256=VZNprqlBXCuWUgtqClNT-NrQmRf-XFYEiRA2BLbf-Sc,7046
-polydb/adapters/AzureQueueAdapter.py,sha256=5PrKAX4OQxUD5nReZKrInF_mjQVdFcj2aYd0Xp-HjjQ,5254
-polydb/adapters/AzureTableStorageAdapter.py,sha256=CTi8qCVQDujqBGIfLJu2fgA2sNkDt07zrNIdyuQIcl4,27053
+polydb/adapters/AzureQueueAdapter.py,sha256=-MLEEAt2yvYjlB5LqT2TwoRa3rVDHDVzXhm1gykqeDM,8052
+polydb/adapters/AzureTableStorageAdapter.py,sha256=FCWojIRyOQdDyga5sxbHXBfZMdb3T1xn3Q2VX5klebo,27824
 polydb/adapters/BlockchainBlobAdapter.py,sha256=D01Yua9mkKfaQrxKYApblIyI6DSP0dtNAh4Tav51HJ4,3299
 polydb/adapters/BlockchainFileAdapter.py,sha256=G749xOVpG20HuKS8zCgi6PMjoJNu-YXK7zitygjLdzM,8335
 polydb/adapters/BlockchainKVAdapter.py,sha256=UFYHyTgvdW-sZUBqyHEG3Cdx6wSTiF2QowEVWL3XPTg,4564
@@ -35,7 +35,7 @@ polydb/adapters/FirestoreAdapter.py,sha256=e3DEODOZ-UAWULLtGTIED-Ym1JrxOKaOLPQVK
 polydb/adapters/GCPFilestoreAdapter.py,sha256=yjFQQwsWYWc8mo8XwMViVTWb5_D--xAyTMvE-4AOpNM,3006
 polydb/adapters/GCPPubSubAdapter.py,sha256=7XNots2VA0ReEDku-rjg-OTYmftIpx5UgnXYDdXNkOo,8692
 polydb/adapters/GCPStorageAdapter.py,sha256=9yS1Jhcn5_rCRdZ5uOqcRW6Ba-UNb6VOYpwENP-C6Qk,7133
-polydb/adapters/MongoDBAdapter.py,sha256=vX3SAHDLbTnHABGesES9N-gYSQqPqdqFLJgd7pYWZzw,7471
+polydb/adapters/MongoDBAdapter.py,sha256=Ak8q_qeAaUTe0Yc2oEefmAbzoODjTWVZQOirW-seBQU,7574
 polydb/adapters/PostgreSQLAdapter.py,sha256=lUe65kpJkTu6R1Tc1zgl63Fa1PI44UVbWRTKRUSSGak,36579
 polydb/adapters/S3Adapter.py,sha256=5R0zHAL2SkGFjp1L3bp-IU468bXYdSf6nKx974MN104,7586
 polydb/adapters/S3CompatibleAdapter.py,sha256=jpafqbAjA8-irdXBrfXa1QJySIzrcUQ6UrFt5h5FAEc,7006
@@ -50,7 +50,7 @@ polydb/audit/__init__.py,sha256=Z7-y5djq3glQ2Yun6nj-13Efpj3oGz9Qc0veS2g06Y4,245
 polydb/audit/context.py,sha256=-A1FMtmr-2snVAHpTrVT80u-D_MCaqX6AoV4Ku2bz_o,1955
 polydb/audit/manager.py,sha256=KzaaOf5bDfr4M-CkCAZBG_U_4xIBCKDLRAf3hsm-DAk,1236
 polydb/audit/models.py,sha256=NapdH5dXU9GMoP9ccbDFaeMWvWbwoh2B5N7Nd3Ci6Cg,3745
-polydb/base/NoSQLKVAdapter.py,sha256=aYEnXG3PZVQbpneSgfToJAhJAsRHUxwazIvjRmT-Qak,13588
+polydb/base/NoSQLKVAdapter.py,sha256=U64nXaeHd40GCZV4DQnogZRUxvI8HHLEhNBMv4oddq4,14491
 polydb/base/ObjectStorageAdapter.py,sha256=VeJ3qXET6H0xd3lJpE8-WSsKs8EyK9S0-9VNR0EJzME,2288
 polydb/base/QueueAdapter.py,sha256=jFgyG-SUK4nhRNxm2NbzUbwnA9b_5iAC-ikLSUpXRwk,799
 polydb/base/SharedFilesAdapter.py,sha256=kXbJmtn_cwEyAZ-1AvFrmesCLSwu43ycTV3S4BmwrO4,853
@@ -60,7 +60,7 @@ polydb/observability/logging.py,sha256=gv1SshNjaSkmR98Uv7Qbwq3gkeQUzVCA4ichqHKL6
 polydb/services/__init__.py,sha256=nMolMXzmhejRSm7f42kU9fCHF0GIpqpejN2kywuBsUQ,241
 polydb/services/compliance_service.py,sha256=-0ncX7PrXy4-NuyWXIv65cLUsqz0jXzb3LtsD8rlrXE,4983
 polydb/services/security_service.py,sha256=q7GzK6sbMnBBsc4fuL4oXTd-ui2b-MYQyrWTBvdVNSk,5062
-altcodepro_polydb_python-2.3.26.dist-info/METADATA,sha256=D5suhSTtKr4f65k7_le2erc4HEM1xXvAF0eh7wn8FFY,12359
-altcodepro_polydb_python-2.3.26.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-altcodepro_polydb_python-2.3.26.dist-info/top_level.txt,sha256=WgLFWJoYjUhwvyPxJFl6jYLrVFuBJDX3OABf4ocwk_E,7
-altcodepro_polydb_python-2.3.26.dist-info/RECORD,,
+altcodepro_polydb_python-2.3.28.dist-info/METADATA,sha256=mCw1bRtSYL37sOtvm-Rn5fQdjfCwLZPcZkAiOk-PN68,12359
+altcodepro_polydb_python-2.3.28.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+altcodepro_polydb_python-2.3.28.dist-info/top_level.txt,sha256=WgLFWJoYjUhwvyPxJFl6jYLrVFuBJDX3OABf4ocwk_E,7
+altcodepro_polydb_python-2.3.28.dist-info/RECORD,,

polydb/adapters/AzureQueueAdapter.py

@@ -46,6 +46,20 @@ class AzureQueueAdapter(QueueAdapter):
         name = re.sub(r"-+", "-", name)  # collapse multiple dashes
         return name.strip("-")
 
+    @staticmethod
+    def _encode_receipt(message_id: str, pop_receipt: str) -> str:
+        # Azure needs BOTH message_id and pop_receipt to delete/update a
+        # message, but the generic queue contract (WorkerPool, SQSAdapter)
+        # only ever carries a single opaque `receipt_handle` string end to
+        # end. Pack both into one string here so ack()/nack() can recover
+        # them without any caller needing to know Azure's two-part scheme.
+        return f"{message_id}|{pop_receipt}"
+
+    @staticmethod
+    def _decode_receipt(receipt_handle: str) -> "tuple[str, str]":
+        message_id, _, pop_receipt = (receipt_handle or "").partition("|")
+        return message_id, pop_receipt
+
     def _initialize_client(self) -> None:
         """Initialize Azure Queue client"""
         from azure.storage.queue import QueueServiceClient
@@ -114,6 +128,13 @@ class AzureQueueAdapter(QueueAdapter):
                     {
                         "id": msg.id,
                         "pop_receipt": msg.pop_receipt,
+                        # WorkerPool (and the generic UDL queue contract)
+                        # reads this key to ack/nack. Without it, ack() is
+                        # always skipped (falsy receipt_handle), the message
+                        # is never deleted, and it silently reappears once
+                        # Azure's visibility timeout elapses — replaying the
+                        # same task forever even after it already ran.
+                        "receipt_handle": self._encode_receipt(msg.id, msg.pop_receipt),
                         "body": payload,
                     }
                 )
@@ -156,8 +177,14 @@ class AzureQueueAdapter(QueueAdapter):
         Preferred usage:
             ack(pop_receipt=..., message_id=...)
 
-        If message_id is not provided, this will fail safely.
+        Generic callers (WorkerPool, storage_router.queue_ack) only pass a
+        single `receipt_handle` positionally and never supply message_id —
+        in that case `pop_receipt` here is actually the combined value
+        produced by `receive()` (`"<message_id>|<pop_receipt>"`), so decode
+        it rather than failing.
         """
+        if not message_id:
+            message_id, pop_receipt = self._decode_receipt(pop_receipt)
         if not message_id:
             raise QueueError("AzureQueueAdapter.ack requires message_id")
         queue_name = self._normalize_queue_name(queue_name)
@@ -166,3 +193,34 @@ class AzureQueueAdapter(QueueAdapter):
             queue_name=queue_name,
             pop_receipt=pop_receipt,
         )
+
+    def nack(
+        self,
+        queue_name: str,
+        ack_id: str,
+        *,
+        delay: Optional[int] = None,
+    ) -> bool:
+        """
+        Make a message visible again (optionally after `delay` seconds)
+        without deleting it, instead of leaving it to reappear only once
+        Azure's default visibility timeout elapses.
+
+        `ack_id` is the combined `"<message_id>|<pop_receipt>"` receipt
+        handle produced by `receive()`. Matches the positional order used
+        by storage_router.queue_nack: nack(queue_name, ack_id, delay=...).
+        """
+        message_id, pop_receipt = self._decode_receipt(ack_id)
+        if not message_id:
+            raise QueueError("AzureQueueAdapter.nack requires a receipt_handle from receive()")
+        try:
+            queue_name = self._normalize_queue_name(queue_name)
+            queue_client = self._get_queue(queue_name)
+            queue_client.update_message(
+                message_id,
+                pop_receipt=pop_receipt,
+                visibility_timeout=delay or 0,
+            )
+            return True
+        except Exception as e:
+            raise QueueError(f"Azure Queue nack failed: {e}")

polydb/adapters/AzureTableStorageAdapter.py

@@ -255,7 +255,7 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
 
         return entity
 
-    def _unpack_entity(self, entity: JsonDict) -> JsonDict:
+    def _unpack_entity(self, model: type, entity: JsonDict) -> JsonDict:
         if not entity:
             return {}
 
@@ -263,6 +263,9 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
         raw.pop("etag", None)
         raw.pop("ETag", None)
         raw.pop("Timestamp", None)
+        # Internal: which model a row belongs to, used only to isolate models
+        # sharing a table. Never part of the public record shape.
+        raw.pop(_MODEL_FIELD, None)
 
         keymap_str = raw.pop("__keymap__", None)
         keymap: Dict[str, str] = {}
@@ -272,26 +275,30 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
             except Exception:
                 keymap = {}
 
-        out: JsonDict = {}
-
-        pk = raw.get("PartitionKey")
-        rk = raw.get("RowKey")
-        if pk is not None:
-            out["PartitionKey"] = pk
-        if rk is not None:
-            out["RowKey"] = rk
+        pk = raw.pop("PartitionKey", None)
+        rk = raw.pop("RowKey", None)
 
+        out: JsonDict = {}
         for k, v in raw.items():
-            if k in ("PartitionKey", "RowKey"):
-                continue
-
-            if k.startswith("_") or k in (_MODEL_FIELD,):
+            if k.startswith("_"):
                 out[k] = v
                 continue
 
             orig_key = keymap.get(k, k)
             out[orig_key] = self._decode_value(v)
 
+        # PartitionKey/RowKey are Azure Table Storage's own physical column
+        # names — never return them as-is. Map each back to the domain field
+        # it was derived from (model's declared partition_key/sort_key, same
+        # resolution _get_pk_rk used to write them), so the same field name
+        # round-trips on read as it did on write. Guarded so we never clobber
+        # a real property that already carries the value (the common case —
+        # pk/rk fields are usually also stored as regular properties).
+        pk_field, rk_field = self._pk_rk_field_names(model)
+        if pk is not None and pk_field not in out:
+            out[pk_field] = pk
+        if rk is not None and rk_field not in out:
+            out[rk_field] = rk
         if "id" not in out and rk is not None:
             out["id"] = rk
 
@@ -491,7 +498,7 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
 
             table_client.upsert_entity(reference_entity)
 
-            restored = self._unpack_entity(entity)
+            restored = self._unpack_entity(model, entity)
             restored["id"] = safe_rk
 
             return restored
@@ -517,7 +524,7 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
 
             restored_entity = self._restore_overflow_properties(entity_dict)
 
-            out = self._unpack_entity(restored_entity)
+            out = self._unpack_entity(model, restored_entity)
             if "id" not in out:
                 out["id"] = safe_rk
 
@@ -589,7 +596,7 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
 
                 restored_entity = self._restore_overflow_properties(ent_dict)
 
-                out = self._unpack_entity(restored_entity)
+                out = self._unpack_entity(model, restored_entity)
 
                 if "id" not in out and "RowKey" in ent_dict:
                     out["id"] = ent_dict["RowKey"]
@@ -705,7 +712,7 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
                 for ent in page:
                     ent_dict = dict(ent)
                     restored = self._restore_overflow_properties(ent_dict)
-                    out = self._unpack_entity(restored)
+                    out = self._unpack_entity(model, restored)
                     if "id" not in out and "RowKey" in ent_dict:
                         out["id"] = ent_dict["RowKey"]
                     items.append(out)

polydb/adapters/MongoDBAdapter.py

@@ -50,7 +50,9 @@ class MongoDBAdapter(NoSQLKVAdapter):
                     self.mongo_uri,
                     maxPoolSize=int(os.getenv("MONGODB_MAX_POOL_SIZE", "10")),
                     minPoolSize=int(os.getenv("MONGODB_MIN_POOL_SIZE", "1")),
-                    serverSelectionTimeoutMS=5000,
+                    serverSelectionTimeoutMS=int(
+                        os.getenv("MONGODB_SERVER_SELECTION_TIMEOUT_MS", "5000")
+                    ),
                 )
 
                 self._client.server_info()

polydb/base/NoSQLKVAdapter.py

@@ -34,6 +34,22 @@ class NoSQLKVAdapter:
         self._lock = threading.Lock()
         self.max_size = 1024 * 1024  # 1MB
 
+    def _pk_rk_field_names(self, model: type) -> Tuple[str, str]:
+        """
+        The domain field names PK/RK were derived from — the mirror image of
+        _get_pk_rk's field resolution. Adapters use this to translate a
+        physical PartitionKey/RowKey (or pk/sk, whatever the backend calls
+        them) back into the model's own field name before returning a record,
+        instead of leaking storage-internal column names to callers. Falls
+        back to the same defaults _get_pk_rk uses (tenant_id / id) when a
+        model declares no explicit mapping, so unmapped models still round-
+        trip cleanly on upsert without erroring.
+        """
+        meta = getattr(model, "__polydb__", {})
+        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")
+        return pk_field, rk_field
+
     def _get_pk_rk(self, model: type, data: JsonDict) -> Tuple[str, str]:
         """Extract PK/RK from model metadata"""
         meta = getattr(model, "__polydb__", {})

polydb/databaseFactory.py

@@ -109,8 +109,8 @@ class EngineOverride:
 
 @dataclass
 class _ResolvedAdapters:
-    sql: PostgreSQLAdapter
-    nosql: NoSQLKVAdapter
+    sql: Optional[PostgreSQLAdapter]
+    nosql: Optional[NoSQLKVAdapter]
     engine_name: str
 
 
@@ -233,35 +233,38 @@ class DatabaseFactory:
     def _resolve_adapters(
         self, model_name: str, storage: str, override: Optional[EngineOverride] = None
     ) -> _ResolvedAdapters:
+        # Only construct the adapter this call actually needs. Every caller
+        # (create/read/update/upsert/delete/query*) branches on `storage` and
+        # touches exactly one of .sql/.nosql — building both unconditionally
+        # meant a purely-SQL deployment with no reachable NoSQL backend (or
+        # vice versa) failed on every single call, not just ones that needed
+        # the missing engine.
+        def _build(engine: "EngineConfig") -> _ResolvedAdapters:
+            return _ResolvedAdapters(
+                sql=engine.sql() if storage == "sql" else None,
+                nosql=engine.nosql() if storage == "nosql" else None,
+                engine_name=engine.name,
+            )
+
         if override:
             engine = self._engine_by_name.get(override.engine_name)
             if engine is None:
                 raise AdapterConfigurationError(
                     f"Unknown engine '{override.engine_name}'. Available: {list(self._engine_by_name)}"
                 )
-            return _ResolvedAdapters(
-                sql=engine.sql(), nosql=engine.nosql(), engine_name=engine.name
-            )
+            return _build(engine)
 
         for engine in self._engines:
             if storage == "sql" and engine.sql_models and model_name in engine.sql_models:
-                return _ResolvedAdapters(
-                    sql=engine.sql(), nosql=engine.nosql(), engine_name=engine.name
-                )
+                return _build(engine)
             if storage == "nosql" and engine.nosql_models and model_name in engine.nosql_models:
-                return _ResolvedAdapters(
-                    sql=engine.sql(), nosql=engine.nosql(), engine_name=engine.name
-                )
+                return _build(engine)
 
         for engine in self._engines:
             if storage == "sql" and engine.is_default_sql:
-                return _ResolvedAdapters(
-                    sql=engine.sql(), nosql=engine.nosql(), engine_name=engine.name
-                )
+                return _build(engine)
             if storage == "nosql" and engine.is_default_nosql:
-                return _ResolvedAdapters(
-                    sql=engine.sql(), nosql=engine.nosql(), engine_name=engine.name
-                )
+                return _build(engine)
 
         raise AdapterConfigurationError(f"No engine for model='{model_name}' storage='{storage}'")
 
@@ -543,14 +546,32 @@ class DatabaseFactory:
             if self._is_sql(meta, engine_override):
                 result = adapters.sql.update(meta.table, entity_id, data)
             else:
+                # A scalar entity_id is usually the record's "id" property,
+                # not its physical PartitionKey/RowKey — those come from the
+                # model's declared pk_field/rk_field (x-metadata partition_key
+                # /sort_key), which for most schema models is a different
+                # field entirely (e.g. Artifact: pk=project_slug, rk=
+                # template_key). Recover both from the patch payload, or —
+                # more reliably — from the record loaded just above as
+                # `before`, so a plain id-addressed update() still lands on
+                # the entity's real physical key instead of a mismatched
+                # default partition / the id used as a row key it never had.
                 pkey = data.get("PartitionKey") or data.get("partition_key") or data.get("pk")
-                en_id = entity_id
+                if not pkey and meta.pk_field:
+                    pkey = data.get(meta.pk_field)
                 if not pkey and before:
                     pkey = (
                         before.get("PartitionKey")
                         or before.get("partition_key")
                         or before.get("pk")
+                        or (before.get(meta.pk_field) if meta.pk_field else None)
                     )
+                rkey = None
+                if meta.rk_field and meta.rk_field != "id":
+                    rkey = data.get(meta.rk_field) or (
+                        before.get(meta.rk_field) if before else None
+                    )
+                en_id = entity_id
                 if pkey:
                     if isinstance(en_id, dict):
                         en_pk = (
@@ -560,8 +581,16 @@ class DatabaseFactory:
                         )
                         if not en_pk:
                             en_id["partition_key"] = pkey
+                        en_rk = (
+                            en_id.get("RowKey")
+                            or en_id.get("row_key")
+                            or en_id.get("rk")
+                            or en_id.get("id")
+                        )
+                        if not en_rk and rkey:
+                            en_id["row_key"] = rkey
                     elif isinstance(en_id, str):
-                        en_id = {"partition_key": pkey, "id": entity_id}
+                        en_id = {"partition_key": pkey, "row_key": rkey or entity_id}
 
                 cls = (
                     model
@@ -702,7 +731,23 @@ class DatabaseFactory:
                     if isinstance(model, type)
                     else type(name, (), {"__polydb__": meta.__dict__})
                 )
-                result = adapters.nosql.delete(cls, entity_id, etag=etag)
+                # Same physical-key recovery as update() (see there for why a
+                # scalar entity_id alone isn't enough once a model's pk_field
+                # /rk_field differ from "id").
+                en_id = entity_id
+                if not isinstance(en_id, dict) and before:
+                    pkey = (
+                        before.get("PartitionKey")
+                        or before.get("partition_key")
+                        or before.get("pk")
+                        or (before.get(meta.pk_field) if meta.pk_field else None)
+                    )
+                    if pkey:
+                        rkey = None
+                        if meta.rk_field and meta.rk_field != "id":
+                            rkey = before.get(meta.rk_field)
+                        en_id = {"partition_key": pkey, "row_key": rkey or entity_id}
+                result = adapters.nosql.delete(cls, en_id, etag=etag)
             success = True
             if self._enable_cache and self._cache:
                 try: