altcodepro-polydb-python 2.5.20__tar.gz → 2.5.21__tar.gz

{altcodepro_polydb_python-2.5.20/src/altcodepro_polydb_python.egg-info → altcodepro_polydb_python-2.5.21}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.5.20
+Version: 2.5.21
 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.5.20 → altcodepro_polydb_python-2.5.21}/src/altcodepro_polydb_python.egg-info/SOURCES.txt

@@ -90,11 +90,13 @@ tests/test_audit_chain_cutover.py
 tests/test_audit_hmac.py
 tests/test_aws.py
 tests/test_azure.py
+tests/test_azure_keyvault_credential.py
 tests/test_azure_queue_receipt_handle.py
 tests/test_azure_table_empty_filter.py
 tests/test_azure_table_id_property_persisted.py
 tests/test_azure_table_id_return_value_sanitization_mismatch.py
 tests/test_azure_table_large_record_patch_roundtrip.py
+tests/test_azure_table_self_heal.py
 tests/test_azure_table_unpack_entity.py
 tests/test_blockchain.py
 tests/test_blockchain_overflow_guard.py

{altcodepro_polydb_python-2.5.20 → altcodepro_polydb_python-2.5.21}/src/polydb/adapters/AzureKeyVaultAdapter.py

@@ -19,10 +19,24 @@ class AzureKeyVaultAdapter(SecretsAdapter):
         self._initialize_client()
 
     def _initialize_client(self) -> None:
-        from azure.identity import DefaultAzureCredential
         from azure.keyvault.secrets import SecretClient
 
-        self._client = SecretClient(vault_url=self.vault_url, credential=DefaultAzureCredential())
+        self._client = SecretClient(vault_url=self.vault_url, credential=self._build_credential())
+
+    @staticmethod
+    def _build_credential():
+        """Inside Azure Container Apps / App Service / Functions a managed identity is available
+        (IDENTITY_ENDPOINT / MSI_ENDPOINT). DefaultAzureCredential tries EnvironmentCredential FIRST, and a deployment that
+        also exports AZURE_CLIENT_ID + AZURE_CLIENT_SECRET (for some other purpose) then fails with AADSTS7000232
+        "MSI identity should not use ClientSecretCredential". So when a managed identity exists it goes first
+        (AZURE_CLIENT_ID, if set, names a user-assigned identity); the normal chain stays as the fallback, so local
+        development (az login, environment variables) behaves as before."""
+        from azure.identity import ChainedTokenCredential, DefaultAzureCredential, ManagedIdentityCredential
+
+        if os.getenv("IDENTITY_ENDPOINT") or os.getenv("MSI_ENDPOINT"):
+            client_id = os.getenv("AZURE_CLIENT_ID") or None
+            return ChainedTokenCredential(ManagedIdentityCredential(client_id=client_id), DefaultAzureCredential())
+        return DefaultAzureCredential()
 
     # Key Vault secret names may only contain alphanumerics and dashes --
     # our secret keys (e.g. "tenant-42/stripe/api_key") use slashes, so

{altcodepro_polydb_python-2.5.20 → altcodepro_polydb_python-2.5.21}/src/polydb/adapters/AzureTableStorageAdapter.py

@@ -47,6 +47,59 @@ _RETRY_TOTAL = int(os.getenv("AZURE_TABLE_RETRY_TOTAL", "3"))
 logging.getLogger("azure").setLevel(logging.ERROR)
 
 
+
+def _is_table_missing(exc: BaseException) -> bool:
+    text = f"{type(exc).__name__} {exc}"
+    return "TableNotFound" in text or "The table specified does not exist" in text
+
+
+class _SelfHealingTableClient:
+    """Wraps an Azure TableClient so a table that disappears while the process is running (deleted by hand, a data
+    reset, a restore) is created again and the operation retried once, instead of failing with TableNotFound until
+    the process restarts. Lazy iterators (query_entities / list_entities) are healed only if the failure happens
+    before the first row was produced."""
+
+    _LAZY = ("query_entities", "list_entities")
+
+    def __init__(self, adapter: "AzureTableStorageAdapter", table_name: str, client: Any):
+        self._adapter = adapter
+        self._table_name = table_name
+        self._client = client
+
+    def _heal(self) -> None:
+        self._adapter._ensured_tables.discard(self._table_name)
+        self._adapter._client.create_table_if_not_exists(self._table_name)
+        self._adapter._ensured_tables.add(self._table_name)
+        logger.warning(f"Azure Table {self._table_name} was missing; created it again")
+
+    def __getattr__(self, name: str):
+        target = getattr(self._client, name)
+        if not callable(target):
+            return target
+        if name in self._LAZY:
+            def lazy(*args, **kwargs):
+                produced = False
+                try:
+                    for item in target(*args, **kwargs):
+                        produced = True
+                        yield item
+                except Exception as exc:  # noqa: BLE001
+                    if produced or not _is_table_missing(exc):
+                        raise
+                    self._heal()
+                    yield from getattr(self._client, name)(*args, **kwargs)
+            return lazy
+
+        def call(*args, **kwargs):
+            try:
+                return target(*args, **kwargs)
+            except Exception as exc:  # noqa: BLE001
+                if not _is_table_missing(exc):
+                    raise
+                self._heal()
+                return getattr(self._client, name)(*args, **kwargs)
+        return call
+
 class AzureTableStorageAdapter(NoSQLKVAdapter):
     """
     Azure Table Storage adapter with:
@@ -441,17 +494,21 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
                 try:
                     self._client.create_table_if_not_exists(table_name)
                     logger.info(f"✅ Azure Table ensured/created: {table_name}")
+                    self._ensured_tables.add(table_name)
                 except Exception as e:
                     msg = str(e)
-                    if "TableAlreadyExists" not in msg and "already exists" not in msg.lower():
-                        logger.warning(f"Could not create table {table_name}: {e}")
-                self._ensured_tables.add(table_name)
+                    if "TableAlreadyExists" in msg or "already exists" in msg.lower():
+                        self._ensured_tables.add(table_name)
+                    else:
+                        # Do NOT remember a failed creation as "ensured": the next call tries again instead of
+                        # failing with TableNotFound for the rest of the process's life.
+                        logger.error(f"Could not create table {table_name}: {e}")
 
             if cached is None:
                 cached = self._client.get_table_client(table_name=table_name)
                 self._table_clients_cache[table_name] = cached
 
-            return cached
+            return _SelfHealingTableClient(self, table_name, cached)
 
     def _restore_overflow_properties(self, entity_dict: JsonDict) -> JsonDict:
         restored = {}

altcodepro_polydb_python-2.5.21/tests/test_azure_keyvault_credential.py

@@ -0,0 +1,34 @@
+"""Inside a managed-identity host the managed identity is tried first, so a stray AZURE_CLIENT_SECRET cannot break Key Vault."""
+import sys
+import types
+from unittest.mock import MagicMock
+
+import pytest
+
+
+@pytest.fixture
+def fake_identity(monkeypatch):
+    mod = types.ModuleType("azure.identity")
+    mod.ChainedTokenCredential = MagicMock(name="Chained")
+    mod.DefaultAzureCredential = MagicMock(name="Default")
+    mod.ManagedIdentityCredential = MagicMock(name="MI")
+    monkeypatch.setitem(sys.modules, "azure.identity", mod)
+    return mod
+
+
+def test_a_managed_identity_host_puts_the_managed_identity_first(fake_identity, monkeypatch):
+    from polydb.adapters.AzureKeyVaultAdapter import AzureKeyVaultAdapter
+    monkeypatch.setenv("IDENTITY_ENDPOINT", "http://169.254.0.1/msi")
+    monkeypatch.setenv("AZURE_CLIENT_ID", "mi-client-id")
+    AzureKeyVaultAdapter._build_credential()
+    fake_identity.ManagedIdentityCredential.assert_called_once_with(client_id="mi-client-id")
+    chain_args = fake_identity.ChainedTokenCredential.call_args.args
+    assert chain_args[0] is fake_identity.ManagedIdentityCredential.return_value and chain_args[1] is fake_identity.DefaultAzureCredential.return_value
+
+
+def test_elsewhere_the_default_chain_is_unchanged(fake_identity, monkeypatch):
+    from polydb.adapters.AzureKeyVaultAdapter import AzureKeyVaultAdapter
+    monkeypatch.delenv("IDENTITY_ENDPOINT", raising=False)
+    monkeypatch.delenv("MSI_ENDPOINT", raising=False)
+    assert AzureKeyVaultAdapter._build_credential() is fake_identity.DefaultAzureCredential.return_value
+    fake_identity.ManagedIdentityCredential.assert_not_called()

altcodepro_polydb_python-2.5.21/tests/test_azure_table_self_heal.py

@@ -0,0 +1,64 @@
+"""A missing Azure Table is created again and the call retried; a failed creation is not remembered as success."""
+from unittest.mock import MagicMock
+
+from polydb.adapters.AzureTableStorageAdapter import _SelfHealingTableClient, _is_table_missing
+
+
+class _Err(Exception):
+    pass
+
+
+def _adapter():
+    a = MagicMock()
+    a._ensured_tables = {"t"}
+    return a
+
+
+def test_detects_the_missing_table_error():
+    assert _is_table_missing(_Err("ErrorCode:TableNotFound"))
+    assert _is_table_missing(_Err("The table specified does not exist."))
+    assert not _is_table_missing(_Err("timeout"))
+
+
+def test_a_call_on_a_missing_table_creates_it_and_retries_once():
+    client = MagicMock()
+    client.get_entity.side_effect = [_Err("TableNotFound"), {"ok": 1}]
+    a = _adapter()
+    got = _SelfHealingTableClient(a, "t", client).get_entity(partition_key="p", row_key="r")
+    assert got == {"ok": 1} and a._client.create_table_if_not_exists.called and "t" in a._ensured_tables
+
+
+def test_other_errors_are_not_swallowed():
+    client = MagicMock()
+    client.get_entity.side_effect = _Err("boom")
+    try:
+        _SelfHealingTableClient(_adapter(), "t", client).get_entity()
+        raise AssertionError("should raise")
+    except _Err:
+        pass
+
+
+def test_a_lazy_query_on_a_missing_table_heals_before_the_first_row():
+    client = MagicMock()
+    def gone():
+        raise _Err("TableNotFound")
+        yield
+    client.query_entities.side_effect = [gone(), iter([{"a": 1}, {"a": 2}])]
+    a = _adapter()
+    rows = list(_SelfHealingTableClient(a, "t", client).query_entities("x"))
+    assert rows == [{"a": 1}, {"a": 2}] and a._client.create_table_if_not_exists.called
+
+
+def test_a_failure_after_rows_were_produced_is_raised_not_replayed():
+    client = MagicMock()
+    def partial():
+        yield {"a": 1}
+        raise _Err("TableNotFound")
+    client.query_entities.return_value = partial()
+    it = _SelfHealingTableClient(_adapter(), "t", client).query_entities("x")
+    assert next(it) == {"a": 1}
+    try:
+        next(it)
+        raise AssertionError("should raise")
+    except _Err:
+        pass