altcodepro-polydb-python 2.3.27__py3-none-any.whl → 2.3.29__py3-none-any.whl

{altcodepro_polydb_python-2.3.27.dist-info → altcodepro_polydb_python-2.3.29.dist-info}/METADATA

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

@@ -1,11 +1,11 @@
-altcodepro_polydb_python-2.3.27.dist-info/licenses/LICENSE,sha256=9X8GLocsBwy-5aR5JGOt2SAMDDPs9Qv-YnqmHBHOXrw,1067
+altcodepro_polydb_python-2.3.29.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=Or3usoXizzrvuZ8X8x8AFdJA4Pul96lqsrGgtVkjTQ4,43861
+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,7 +23,7 @@ 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/AzureQueueAdapter.py,sha256=LsNvrNHUgFF2UwXXTwlOiqK8VdP4htLaFnTu4oxZDlo,9468
 polydb/adapters/AzureTableStorageAdapter.py,sha256=FCWojIRyOQdDyga5sxbHXBfZMdb3T1xn3Q2VX5klebo,27824
 polydb/adapters/BlockchainBlobAdapter.py,sha256=D01Yua9mkKfaQrxKYApblIyI6DSP0dtNAh4Tav51HJ4,3299
 polydb/adapters/BlockchainFileAdapter.py,sha256=G749xOVpG20HuKS8zCgi6PMjoJNu-YXK7zitygjLdzM,8335
@@ -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
@@ -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.27.dist-info/METADATA,sha256=U0hT_pcZTOTdbyTH2CzkFvasDDyRqnNRxbyB3zeSby0,12359
-altcodepro_polydb_python-2.3.27.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-altcodepro_polydb_python-2.3.27.dist-info/top_level.txt,sha256=WgLFWJoYjUhwvyPxJFl6jYLrVFuBJDX3OABf4ocwk_E,7
-altcodepro_polydb_python-2.3.27.dist-info/RECORD,,
+altcodepro_polydb_python-2.3.29.dist-info/METADATA,sha256=7bWio-A4c46Q0twrvo3OX7m5s3wYBpfR0NajgheWDgQ,12359
+altcodepro_polydb_python-2.3.29.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+altcodepro_polydb_python-2.3.29.dist-info/top_level.txt,sha256=WgLFWJoYjUhwvyPxJFl6jYLrVFuBJDX3OABf4ocwk_E,7
+altcodepro_polydb_python-2.3.29.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
@@ -96,15 +110,38 @@ class AzureQueueAdapter(QueueAdapter):
         except Exception as e:
             raise QueueError(f"Azure Queue send failed: {e}")
 
+    # How long a delivered message stays invisible to other consumers before
+    # Azure hands it out again. The SDK's own default is 30s — far shorter
+    # than a real task (an LLM generation call alone can run 30-120s+), so
+    # a still-in-flight message was becoming visible again and getting
+    # picked up by a second worker mid-processing: two concurrent
+    # executions of the same task, one of which stomps/duplicates the
+    # other's result. 300s covers realistic worst-case processing; ack()
+    # deletes the message immediately on completion regardless; a genuinely
+    # crashed worker still recovers the message after this timeout.
+    DEFAULT_VISIBILITY_TIMEOUT = 300
+
     @retry(max_attempts=3, delay=1.0, exceptions=(QueueError,))
-    def receive(self, queue_name: str = "default", max_messages: int = 1) -> List[Dict[str, Any]]:
+    def receive(
+        self,
+        queue_name: str = "default",
+        max_messages: int = 1,
+        visibility_timeout: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
         """Receive messages"""
         try:
 
             queue_name = self._normalize_queue_name(queue_name)
             queue_client = self._get_queue(queue_name)
 
-            messages = queue_client.receive_messages(max_messages=max_messages)
+            messages = queue_client.receive_messages(
+                max_messages=max_messages,
+                visibility_timeout=(
+                    visibility_timeout
+                    if visibility_timeout is not None
+                    else self.DEFAULT_VISIBILITY_TIMEOUT
+                ),
+            )
 
             results = []
 
@@ -114,6 +151,19 @@ 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),
+                        # How many times Azure has handed this same message
+                        # out (1 on first delivery). Lets a consumer (e.g.
+                        # WorkerPool) detect a poison message that keeps
+                        # failing to ack/process and dead-letter it instead
+                        # of retrying forever.
+                        "dequeue_count": msg.dequeue_count,
                         "body": payload,
                     }
                 )
@@ -156,8 +206,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 +222,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/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/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}'")