altcodepro-polydb-python 2.5.12__tar.gz → 2.5.18__tar.gz

{altcodepro_polydb_python-2.5.12/src/altcodepro_polydb_python.egg-info → altcodepro_polydb_python-2.5.18}/PKG-INFO

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

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

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

@@ -94,6 +94,7 @@ 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_unpack_entity.py
 tests/test_blockchain.py
 tests/test_blockchain_overflow_guard.py
@@ -111,6 +112,7 @@ tests/test_nosql_operator_injection.py
 tests/test_observability.py
 tests/test_overflow_gc.py
 tests/test_postgresql.py
+tests/test_postgresql_deserialize_row.py
 tests/test_queue_extend_delay_cancel.py
 tests/test_rabbitmq.py
 tests/test_redis_kv.py

{altcodepro_polydb_python-2.5.12 → altcodepro_polydb_python-2.5.18}/src/polydb/__init__.py

@@ -4,7 +4,7 @@ PolyDB - Enterprise Cloud-Independent Database Abstraction
 Full LINQ support, field-level audit, cache, soft delete, overflow storage
 """
 
-__version__ = "2.5.12"
+__version__ = "2.5.18"
 
 from .aio import AsyncDatabaseFactory, AsyncPolyDB
 from .audit.context import AuditContext

{altcodepro_polydb_python-2.5.12 → altcodepro_polydb_python-2.5.18}/src/polydb/adapters/AzureTableStorageAdapter.py

@@ -125,6 +125,19 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
         s = re.sub(r"[\\/#\?\x00-\x1f\x7f:+ ]", "_", s)
         return s[:1024] if len(s) > 1024 else s
 
+    def _check_overflow(self, data: JsonDict):  # type: ignore[override]
+        """Azure overflows per PROPERTY inside `_put_raw`, never per record.
+
+        The base class' whole-record overflow replaces the record with a stub
+        of underscore keys (`_overflow`, `_blob_key`, ...), but `_put_raw`
+        drops every key starting with "_" when it builds the entity -- so the
+        stub's pointer was never stored and the real fields of the write were
+        silently lost (only an orphaned blob remained). Returning the data
+        untouched lets `_put_raw` spill each >30KB property on its own, which
+        `_get_raw`/`_query_raw` already rehydrate.
+        """
+        return data, None
+
     def _sanitize_prop_name(self, name: Any) -> str:
         s = str(name)
         s = re.sub(r"[^A-Za-z0-9_]", "_", s)

{altcodepro_polydb_python-2.5.12 → altcodepro_polydb_python-2.5.18}/src/polydb/adapters/PostgreSQLAdapter.py

@@ -365,6 +365,50 @@ class PostgreSQLAdapter:
         return [self._serialize_param(p) for p in params]
 
     def _deserialize_row(self, row: JsonDict) -> JsonDict:
+        """Best-effort convenience decode: any string column value that
+        LOOKS like JSON (starts/ends with `{}`/`[]`) is `json.loads`'d,
+        regardless of the column's own declared type. This is a real,
+        deliberate, LOAD-BEARING convenience a real caller depends on --
+        e.g. universal-interprter's `observability.py`'s `Observability.
+        query()` writes a `logs.emit` payload as `json.dumps(...)` into a
+        plain TEXT column (`payload`, never JSONB -- see that module's
+        own comment) and its own docstring explicitly promises "logs.
+        query's own `payload` field gets a real dict back"; removing this
+        heuristic (briefly tried, then reverted -- see this repo's own
+        2.5.16/2.5.17 CLAUDE.md history) silently broke that real,
+        already-shipped contract. `query_log.py`'s own `fields` column is
+        the identical shape, just defended a second way: it independently
+        `json.loads`'s its own value with an `isinstance(..., str)` guard
+        rather than relying on this method at all -- proof this repo has
+        real callers on both sides (some lean on this adapter-level
+        decode, some defend for themselves).
+
+        **The real, honest trade-off, unavoidable at this layer**: a
+        genuinely non-JSON TEXT/VARCHAR string whose own real content
+        merely LOOKS JSON-shaped (e.g. a prompt template's own `content`
+        column holding a literal JSON-encoded email template -- see
+        universal-interprter's `prompt_template_store.py`) gets coerced
+        from `str` to `dict`/`list` here too, since this method has no
+        way to distinguish "real app data serialized as JSON text" from
+        "a legitimately JSON-shaped string that must stay a string" --
+        both are simply "a string that starts with `{` and ends with
+        `}`." This adapter deliberately does NOT try to solve that
+        ambiguity generically (declaring the column JSONB instead sidesteps
+        it entirely -- psycopg2 registers global JSON/JSONB typecasters
+        for OIDs 114/3802 automatically at import time, so a genuine
+        `json`/`jsonb` column never even reaches this heuristic, `isinstance
+        (v, str)` already `False` by the time this method sees it); a
+        caller that must keep a TEXT column's string content literal
+        despite it being JSON-shaped owns that coercion at ITS OWN layer
+        instead (see `prompt_template_store.py`'s own `_coerce_content_to_str`
+        for the concrete pattern: re-`json.dumps()` a `content` value that
+        came back non-`str`, restoring the real string every caller of
+        that store is promised). This adapter stays a "dumb storage
+        layer" in the sense that it never MODELS what a column's real
+        semantic type should be -- it does still apply this one generic,
+        best-effort convenience decode uniformly, exactly as it always
+        has.
+        """
         for k, v in list(row.items()):
             if isinstance(v, str):
                 s = v.strip()

{altcodepro_polydb_python-2.5.12 → altcodepro_polydb_python-2.5.18}/src/polydb/schema.py

@@ -61,6 +61,17 @@ class Index:
     name: str
     columns: List[str]
     unique: bool = False
+    # Postgres index access method -- "btree" (the default, and the only
+    # one Postgres actually permits combined with UNIQUE) plus the real
+    # non-default methods a caller may need for a specific column shape:
+    # "gin"/"gist" (full-text search, JSONB containment, array overlap),
+    # "hash" (equality-only, smaller than btree for that one case), "brin"
+    # (large, naturally-ordered, append-mostly columns -- cheap to
+    # maintain relative to btree at real scale). Never validated against
+    # Postgres's own real per-type support here -- that's a live DDL
+    # concern the caller's own database will enforce; this dataclass only
+    # carries the caller's choice through to the generated statement.
+    using: str = "btree"
 
 
 class SchemaBuilder:
@@ -128,10 +139,17 @@ class SchemaBuilder:
 
         for idx in self.indexes:
             unique = "UNIQUE " if idx.unique else ""
+            # "btree" omitted outright rather than spelled out as
+            # "USING btree" -- it's Postgres's own implicit default, and
+            # every index this codebase generated before `using` existed
+            # rendered without a USING clause at all; emitting it only for
+            # a non-default method keeps every pre-existing caller's own
+            # generated SQL text byte-for-byte unchanged.
+            using = f"USING {idx.using} " if idx.using != "btree" else ""
             cols = ", ".join(validate_column_name(c) for c in idx.columns)
             sql = (
                 f"CREATE {unique}INDEX IF NOT EXISTS {validate_table_name(idx.name)} "
-                f"ON {table_name}({cols});"
+                f"ON {table_name}{' ' if using else ''}{using}({cols});"
             )
             statements.append(sql)
 

altcodepro_polydb_python-2.5.18/tests/test_azure_table_large_record_patch_roundtrip.py

@@ -0,0 +1,118 @@
+"""Unit tests (no Azurite needed) for a real, reproduced data-loss bug.
+
+`NoSQLKVAdapter.put()/patch()` run `_check_overflow()` on the WHOLE record
+before calling `_put_raw()`. `AzureTableStorageAdapter` sets `max_size` to
+60KB (it has its own per-PROPERTY overflow for strings > 30KB inside
+`_put_raw`), so any record above 60KB was replaced by a whole-record stub
+`{_overflow, _blob_key, _size, _checksum}`. `_put_raw` then skips every key
+starting with "_" when it builds the entity, so the stub's pointer was never
+stored and the update's real fields (content_url, version, ...) were never
+written -- a silent drop that left only an orphaned blob. Seen live: a
+~41KB generated document plus its prompt context pushed an `artifacts` row
+over 60KB; `core.db.update` reported success but the re-read row had none
+of the fields.
+"""
+
+import threading
+
+import pytest
+
+pytest.importorskip("azure.data.tables")
+
+from polydb.adapters.AzureTableStorageAdapter import AzureTableStorageAdapter  # noqa: E402
+
+
+class _Model:
+    __name__ = "artifacts"
+    __qualname__ = "artifacts"
+    __polydb__ = {"pk_field": "project_slug", "rk_field": "artifact_id"}
+
+
+class _FakeTableClient:
+    def __init__(self):
+        self.store = {}
+
+    def upsert_entity(self, entity, **kw):
+        key = (entity["PartitionKey"], entity["RowKey"])
+        merged = dict(self.store.get(key, {}))
+        merged.update(entity)  # azure MERGE semantics
+        self.store[key] = merged
+
+    def get_entity(self, pk, rk):
+        return dict(self.store[(pk, rk)])
+
+
+def _adapter():
+    fake = _FakeTableClient()
+    blobs = {}
+    adp = object.__new__(AzureTableStorageAdapter)
+    adp.max_size = AzureTableStorageAdapter.AZURE_TABLE_MAX_SIZE
+    adp.partition_config = None
+    adp._lock = threading.Lock()
+
+    class _ObjStore:  # what the base class' whole-record overflow writes to
+        def put(self, key, data):
+            blobs[key] = data
+
+        def get(self, key):
+            return blobs[key]
+
+    adp.object_storage = _ObjStore()
+    adp._blob_service = None
+    adp._get_table_client = lambda model: fake
+    adp._blob_upload = lambda key, data: blobs.__setitem__(key, data)
+    adp._blob_download = lambda key: blobs[key]
+    return adp, fake, blobs
+
+
+def _row(**extra):
+    base = {"project_slug": "p-1", "artifact_id": "a-1", "status": "generating", "version": 0}
+    base.update(extra)
+    return base
+
+
+def test_patch_of_a_record_over_60kb_keeps_every_field():
+    adp, fake, blobs = _adapter()
+    adp.put(_Model, _row())
+
+    big = "x" * (45 * 1024)
+    adp.patch(
+        _Model,
+        {"pk": "p-1", "rk": "a-1"},
+        {
+            "content": big,
+            "system_prompt": "y" * (40 * 1024),
+            "content_url": "https://example/blob/1",
+            "content_blob_key": "blob-1",
+            "version": 1,
+            "preview_text": "# Title...",
+        },
+    )
+
+    row = adp._get_raw(_Model, "p-1", "a-1")
+    assert row["content"] == big
+    assert row["content_url"] == "https://example/blob/1"
+    assert row["content_blob_key"] == "blob-1"
+    assert row["version"] == 1
+    assert row["preview_text"] == "# Title..."
+    assert row["status"] == "generating"
+
+
+def test_later_small_patch_does_not_lose_the_large_fields():
+    adp, fake, blobs = _adapter()
+    adp.put(_Model, _row())
+    big = "z" * (50 * 1024)
+    adp.patch(_Model, {"pk": "p-1", "rk": "a-1"}, {"content": big, "system_prompt": "q" * 50000})
+    adp.patch(_Model, {"pk": "p-1", "rk": "a-1"}, {"status": "validating"})
+
+    row = adp._get_raw(_Model, "p-1", "a-1")
+    assert row["status"] == "validating"
+    assert row["content"] == big
+
+
+def test_no_whole_record_stub_is_ever_written_for_azure():
+    adp, fake, blobs = _adapter()
+    adp.put(_Model, _row(content="w" * (70 * 1024)))
+    stored = fake.store[("p-1", "a-1")]
+    assert "_overflow" not in stored and not any(k.startswith("overflow/") for k in blobs)
+    assert stored["status"] == "generating"

altcodepro_polydb_python-2.5.18/tests/test_postgresql_deserialize_row.py

@@ -0,0 +1,120 @@
+"""PostgreSQLAdapter._deserialize_row's best-effort JSON-shaped-string
+decode -- real, load-bearing behavior a real caller depends on, plus the
+honest trade-off it can't avoid.
+
+History: this heuristic (`json.loads()` any string column value that
+starts/ends with `{}`/`[]`, regardless of the column's own declared
+type) was briefly REMOVED in 2.5.16 after a real, reproduced bug --
+universal-interprter's `prompt_template_store.py` stores an email
+template's `content` as a plain TEXT column holding a JSON-encoded
+string, and reading it back silently coerced it from `str` to `dict`,
+crashing `prompt.render` -> `text.template`'s `template.replace(...)`
+with `'dict' object has no attribute 'replace'`. That removal was itself
+a real regression, reverted in 2.5.17: universal-interprter's own
+`observability.py` (`Observability.query()`) writes a `logs.emit`
+payload as `json.dumps(...)` into a plain TEXT column (`payload`, never
+JSONB) and its own docstring explicitly promises "logs.query's own
+`payload` field gets a real dict back" -- a real, already-shipped
+contract this heuristic is the only thing that ever fulfilled, since
+that read path is a raw `sql_adapter.execute()` call with no explicit
+parsing of its own (unlike `query_log.py`'s own `fields` column, the
+identical shape, which defends itself with an `isinstance(..., str)`
+guard + its own `json.loads()` rather than relying on this method).
+
+The real, honest trade-off (unavoidable at this layer, see
+_deserialize_row's own docstring): a TEXT column can never be told apart
+from a JSONB one purely by string-sniffing its OWN value's shape, so a
+caller that must keep a TEXT column's real string content literal
+despite it looking JSON-shaped (like `prompt_template_store.py`'s
+`content`) owns that coercion at ITS OWN layer -- see that module's own
+`_coerce_content_to_str` in universal-interprter for the concrete
+pattern. No live Postgres connection is needed for any of this --
+`_deserialize_row` is a pure dict-in/dict-out method.
+"""
+
+from __future__ import annotations
+
+from polydb.adapters.PostgreSQLAdapter import PostgreSQLAdapter
+
+
+def _adapter() -> PostgreSQLAdapter:
+    # __init__ eagerly opens a real connection pool (no lazy-connect mode
+    # exists) -- _deserialize_row touches no instance state at all, so a
+    # bare, uninitialized instance is enough to exercise it without a
+    # live Postgres.
+    return object.__new__(PostgreSQLAdapter)
+
+
+class TestDeserializeRowDecodesJsonShapedStrings:
+    def test_a_json_object_shaped_string_is_parsed_into_a_dict(self):
+        # The real, load-bearing case: a caller (e.g. observability.py's
+        # own `payload` column) wrote `json.dumps(...)` into a plain TEXT
+        # column and expects a real dict back on read.
+        adapter = _adapter()
+        row = {"id": "1", "payload": '{"event": "otp_sent", "channel": "email"}'}
+
+        result = adapter._deserialize_row(dict(row))
+
+        assert result["payload"] == {"event": "otp_sent", "channel": "email"}
+
+    def test_a_json_array_shaped_string_is_parsed_into_a_list(self):
+        adapter = _adapter()
+        row = {"id": "1", "fields": '["email", "status"]'}
+
+        result = adapter._deserialize_row(dict(row))
+
+        assert result["fields"] == ["email", "status"]
+
+    def test_a_string_that_merely_looks_json_shaped_but_isnt_valid_json_is_left_alone(self):
+        adapter = _adapter()
+        row = {"id": "1", "notes": "{not actually valid json}"}
+
+        result = adapter._deserialize_row(dict(row))
+
+        assert result["notes"] == row["notes"]
+        assert isinstance(result["notes"], str)
+
+    def test_an_ordinary_scalar_string_is_untouched(self):
+        adapter = _adapter()
+        row = {"id": "1", "name": "plain text, not json at all"}
+
+        result = adapter._deserialize_row(dict(row))
+
+        assert result == row
+
+    def test_a_real_dict_value_already_parsed_by_the_driver_passes_through_unchanged(self):
+        # This is what a genuine json/jsonb column already looks like by
+        # the time _deserialize_row runs -- psycopg2's own global
+        # typecasters (OIDs 114/3802) already turned it into a native
+        # dict, so there is nothing left for this method to do.
+        adapter = _adapter()
+        row = {"id": "1", "metadata": {"subject": "hi"}}
+
+        result = adapter._deserialize_row(dict(row))
+
+        assert result == row
+        assert isinstance(result["metadata"], dict)
+
+    def test_none_and_non_string_values_are_left_alone(self):
+        adapter = _adapter()
+        row = {"id": "1", "deleted_at": None, "count": 3, "active": True}
+
+        result = adapter._deserialize_row(dict(row))
+
+        assert result == row
+
+    def test_the_honest_trade_off_a_json_shaped_string_that_is_meant_to_stay_literal_text_still_gets_coerced(
+        self,
+    ):
+        # The real cost this heuristic imposes, documented rather than
+        # hidden: a caller owning a TEXT column whose real content
+        # happens to be JSON-shaped (e.g. prompt_template_store.py's own
+        # `content`) must defend against this itself -- this adapter has
+        # no way to know that a given TEXT value should stay a literal
+        # string instead of being decoded.
+        adapter = _adapter()
+        row = {"id": "1", "content": '{"subject": "hi", "html": "<p>{{code}}</p>"}'}
+
+        result = adapter._deserialize_row(dict(row))
+
+        assert isinstance(result["content"], dict)  # not the literal string it was written as

{altcodepro_polydb_python-2.5.12 → altcodepro_polydb_python-2.5.18}/tests/test_schema_ddl_injection.py

@@ -140,3 +140,33 @@ class TestLegitimateSchemasStillBuild:
         assert builder.to_create_indexes("users") == [
             "CREATE UNIQUE INDEX IF NOT EXISTS idx_users_email ON users(email, id);"
         ]
+
+
+class TestIndexUsingClause:
+    """Index.using (default "btree") -- added to let a caller pick a
+    non-default Postgres index access method (gin/gist/hash/brin) for a
+    specific column shape, without touching the default btree case's own
+    generated SQL text at all."""
+
+    def test_default_btree_renders_with_no_using_clause_at_all(self):
+        # Every Index constructed before `using` existed implicitly meant
+        # btree -- this proves that default still renders byte-for-byte
+        # identical to the pre-`using` SQL (no "USING btree" ever emitted).
+        builder = _builder().add_index(Index(name="idx_users_email", columns=["email"]))
+        assert builder.to_create_indexes("users") == [
+            "CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);"
+        ]
+
+    def test_non_default_using_is_rendered_between_table_name_and_columns(self):
+        builder = _builder().add_index(Index(name="idx_users_tags", columns=["tags"], using="gin"))
+        assert builder.to_create_indexes("users") == [
+            "CREATE INDEX IF NOT EXISTS idx_users_tags ON users USING gin (tags);"
+        ]
+
+    def test_unique_and_a_non_default_using_compose(self):
+        builder = _builder().add_index(
+            Index(name="idx_users_key", columns=["key"], unique=True, using="hash")
+        )
+        assert builder.to_create_indexes("users") == [
+            "CREATE UNIQUE INDEX IF NOT EXISTS idx_users_key ON users USING hash (key);"
+        ]