altcodepro-polydb-python 2.3.27__tar.gz → 2.3.29__tar.gz

{altcodepro_polydb_python-2.3.27/src/altcodepro_polydb_python.egg-info → altcodepro_polydb_python-2.3.29}/PKG-INFO

@@ -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 → altcodepro_polydb_python-2.3.29}/pyproject.toml

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

@@ -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 → altcodepro_polydb_python-2.3.29}/src/altcodepro_polydb_python.egg-info/SOURCES.txt

@@ -78,6 +78,7 @@ src/polydb/services/security_service.py
 tests/test_atomic_decrement.py
 tests/test_aws.py
 tests/test_azure.py
+tests/test_azure_queue_receipt_handle.py
 tests/test_azure_table_empty_filter.py
 tests/test_azure_table_unpack_entity.py
 tests/test_blockchain.py

{altcodepro_polydb_python-2.3.27 → altcodepro_polydb_python-2.3.29}/src/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}")

{altcodepro_polydb_python-2.3.27 → altcodepro_polydb_python-2.3.29}/src/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()

{altcodepro_polydb_python-2.3.27 → altcodepro_polydb_python-2.3.29}/src/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}'")
 

altcodepro_polydb_python-2.3.29/tests/test_azure_queue_receipt_handle.py

@@ -0,0 +1,185 @@
+"""
+tests/test_azure_queue_receipt_handle.py
+=========================================
+Regression coverage for the receipt_handle contract on AzureQueueAdapter.
+
+Bug this guards against: `receive()` used to return only `id` and
+`pop_receipt`, never the `receipt_handle` key that WorkerPool (and every
+other adapter's ack contract) reads. That made
+`WorkerPool._process_message`'s `msg.get("receipt_handle")` always `None`,
+so the ack branch was silently skipped, the message was never deleted, and
+Azure redelivered it once its visibility timeout elapsed — replaying the
+same task forever even after it had already run to completion.
+
+These tests mock the Azure SDK entirely (no live Azurite needed) and only
+exercise the adapter's own encode/decode + ack/nack wiring.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+# test_atomic_decrement.py stubs sys.modules["azure"] et al. with bare,
+# path-less ModuleType objects (guarded by `if _mod not in sys.modules`) so
+# it can run without cloud SDKs installed. If it collects before this file
+# (alphabetically it does), that stub wins the module cache for the rest of
+# the process, and the adapter's lazy `from azure.core.exceptions import
+# ...` imports then fail with "'azure' is not a package" -- even though the
+# real azure SDK is installed here. Drop any such stubs so this file always
+# imports the genuine package fresh.
+for _name in list(sys.modules):
+    if _name == "azure" or _name.startswith("azure."):
+        del sys.modules[_name]
+
+from polydb.adapters.AzureQueueAdapter import AzureQueueAdapter
+
+
+def _make_adapter() -> AzureQueueAdapter:
+    # Bypass the real Azure SDK entirely -- when the full suite runs
+    # together, other providers' tests leave azure.storage.queue in a state
+    # where importing QueueServiceClient from it fails (a pre-existing
+    # cross-test import-cache issue, unrelated to this adapter). Skipping
+    # `_initialize_client` sidesteps that import altogether; these tests
+    # only care about the adapter's own encode/decode + ack/nack wiring.
+    with patch.object(AzureQueueAdapter, "_initialize_client", lambda self: None):
+        adapter = AzureQueueAdapter(connection_string="UseDevelopmentStorage=true")
+    adapter._client = MagicMock()
+    return adapter
+
+
+def _mock_queue_client(adapter: AzureQueueAdapter, queue_name: str = "default") -> MagicMock:
+    client = MagicMock()
+    adapter._queues[adapter._normalize_queue_name(queue_name)] = client
+    return client
+
+
+class TestReceiveReturnsReceiptHandle:
+    def test_receive_includes_receipt_handle_key(self):
+        adapter = _make_adapter()
+        client = _mock_queue_client(adapter)
+
+        raw_msg = MagicMock()
+        raw_msg.id = "msg-123"
+        raw_msg.pop_receipt = "pop-abc"
+        raw_msg.content = json.dumps({"hello": "world"})
+        client.receive_messages.return_value = [raw_msg]
+
+        [received] = adapter.receive(queue_name="default", max_messages=1)
+
+        assert received["id"] == "msg-123"
+        assert received["pop_receipt"] == "pop-abc"
+        assert "receipt_handle" in received
+        assert received["receipt_handle"]  # truthy -- WorkerPool checks `if receipt_handle`
+
+    def test_receive_surfaces_dequeue_count(self):
+        """WorkerPool's poison-message guard thresholds on this to
+        dead-letter a message the queue keeps redelivering."""
+        adapter = _make_adapter()
+        client = _mock_queue_client(adapter)
+
+        raw_msg = MagicMock()
+        raw_msg.id = "msg-123"
+        raw_msg.pop_receipt = "pop-abc"
+        raw_msg.content = json.dumps({"hello": "world"})
+        raw_msg.dequeue_count = 7
+        client.receive_messages.return_value = [raw_msg]
+
+        [received] = adapter.receive(queue_name="default", max_messages=1)
+
+        assert received["dequeue_count"] == 7
+
+    def test_receipt_handle_round_trips_through_decode(self):
+        message_id, pop_receipt = AzureQueueAdapter._decode_receipt(
+            AzureQueueAdapter._encode_receipt("msg-123", "pop-abc")
+        )
+        assert message_id == "msg-123"
+        assert pop_receipt == "pop-abc"
+
+    def test_receive_defaults_to_a_long_visibility_timeout(self):
+        """The Azure SDK's own default (30s) is shorter than a real task
+        can take (an LLM call alone can run 30-120s+), so a still-in-flight
+        message became visible again and got picked up by a second worker
+        mid-processing -- two concurrent executions of the same task. This
+        guards against that default silently regressing back to 30s (or
+        being dropped entirely, which is the SDK's fallback)."""
+        adapter = _make_adapter()
+        client = _mock_queue_client(adapter)
+        client.receive_messages.return_value = []
+
+        adapter.receive(queue_name="default", max_messages=1)
+
+        _, kwargs = client.receive_messages.call_args
+        assert kwargs["visibility_timeout"] == AzureQueueAdapter.DEFAULT_VISIBILITY_TIMEOUT
+        assert kwargs["visibility_timeout"] >= 300
+
+    def test_receive_honours_an_explicit_visibility_timeout(self):
+        adapter = _make_adapter()
+        client = _mock_queue_client(adapter)
+        client.receive_messages.return_value = []
+
+        adapter.receive(queue_name="default", max_messages=1, visibility_timeout=45)
+
+        _, kwargs = client.receive_messages.call_args
+        assert kwargs["visibility_timeout"] == 45
+
+
+class TestAckAcceptsSingleReceiptHandle:
+    def test_ack_with_generic_single_arg_deletes_using_decoded_parts(self):
+        """Mirrors how WorkerPool/storage_router actually call ack():
+        queue.ack(receipt_handle, queue_name) -- a single positional value,
+        never a separate message_id.
+        """
+        adapter = _make_adapter()
+        client = _mock_queue_client(adapter)
+
+        receipt_handle = AzureQueueAdapter._encode_receipt("msg-123", "pop-abc")
+        result = adapter.ack(receipt_handle, "default")
+
+        assert result is True
+        client.delete_message.assert_called_once_with("msg-123", "pop-abc")
+
+    def test_ack_still_supports_explicit_message_id(self):
+        adapter = _make_adapter()
+        client = _mock_queue_client(adapter)
+
+        result = adapter.ack("pop-abc", "default", message_id="msg-123")
+
+        assert result is True
+        client.delete_message.assert_called_once_with("msg-123", "pop-abc")
+
+    def test_ack_raises_if_receipt_handle_has_no_message_id(self):
+        adapter = _make_adapter()
+        _mock_queue_client(adapter)
+
+        with pytest.raises(Exception):
+            adapter.ack("", "default")
+
+
+class TestNack:
+    def test_nack_updates_visibility_without_deleting(self):
+        adapter = _make_adapter()
+        client = _mock_queue_client(adapter)
+
+        receipt_handle = AzureQueueAdapter._encode_receipt("msg-123", "pop-abc")
+        result = adapter.nack("default", receipt_handle, delay=30)
+
+        assert result is True
+        client.update_message.assert_called_once_with(
+            "msg-123", pop_receipt="pop-abc", visibility_timeout=30
+        )
+        client.delete_message.assert_not_called()
+
+    def test_nack_defaults_delay_to_zero(self):
+        adapter = _make_adapter()
+        client = _mock_queue_client(adapter)
+
+        receipt_handle = AzureQueueAdapter._encode_receipt("msg-123", "pop-abc")
+        adapter.nack("default", receipt_handle)
+
+        client.update_message.assert_called_once_with(
+            "msg-123", pop_receipt="pop-abc", visibility_timeout=0
+        )