sqlmodel-ext 0.5.2__tar.gz → 0.5.3__tar.gz

{sqlmodel_ext-0.5.2 → sqlmodel_ext-0.5.3}/CHANGELOG.md

@@ -7,6 +7,24 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 > there is no stability or backward-compatibility guarantee between versions, and
 > you use it at your own risk. Pin the exact version you depend on.
 
+## [0.5.3]
+
+### Fixed
+
+- After `session.invalidate()`, a session that kept being used skipped the Redis cache
+  for every read and write on the tables it had written in the invalidated transaction.
+  `invalidate()` ends the transaction without dispatching `after_rollback`, so the
+  pending-invalidation dict was never cleared, and that dict is also one of the sources
+  of the "uncommitted writes" check that makes `get()` bypass the cache. The dict is now
+  cleared when the outermost transaction ends, the same place that already cleared the
+  flushed-tables set. Commit, rollback, `close()` and `reset()` were not affected. The
+  cache contents were always correct; the effect was lost cache hits, not stale data.
+- A fresh `pip install sqlmodel-ext` could not be imported: SQLAlchemy 2.1 no longer
+  installs `greenlet` by default, and `sqlmodel_ext` imports `sqlalchemy.ext.asyncio` when
+  the package is imported, which raised `ImportError` without it. The dependency is now
+  `sqlalchemy[asyncio]`, which installs `greenlet`. Environments that already had
+  `greenlet` (or SQLAlchemy 2.0) were not affected. Also present in 0.5.2 and earlier.
+
 ## [0.5.2]
 
 ### Fixed

{sqlmodel_ext-0.5.2 → sqlmodel_ext-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sqlmodel-ext
-Version: 0.5.2
+Version: 0.5.3
 Summary: Extended SQLModel infrastructure: smart metaclass, async CRUD mixins, polymorphic inheritance, optimistic locking, relation preloading, and reusable field types.
 Project-URL: Homepage, https://github.com/Foxerine/sqlmodel-ext
 Project-URL: Repository, https://github.com/Foxerine/sqlmodel-ext
@@ -23,7 +23,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Requires-Dist: pydantic>=2.12
-Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: sqlalchemy[asyncio]>=2.0
 Requires-Dist: sqlmodel>=0.0.32
 Requires-Dist: typing-extensions>=4.14.1
 Provides-Extra: alembic

{sqlmodel_ext-0.5.2 → sqlmodel_ext-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlmodel-ext"
-version = "0.5.2"
+version = "0.5.3"
 description = "Extended SQLModel infrastructure: smart metaclass, async CRUD mixins, polymorphic inheritance, optimistic locking, relation preloading, and reusable field types."
 readme = "README.md"
 license = "MIT"
@@ -32,7 +32,9 @@ dependencies = [
     # 2.12 is the first release shipping ``pydantic.experimental.missing_sentinel.MISSING``
     # (the object ``Unset`` is) and ``Field(exclude_if=...)`` (behind ``EXCLUDE_IF_NONE``).
     "pydantic>=2.12",
-    "sqlalchemy>=2.0",
+    # The ``asyncio`` extra pulls in ``greenlet``: ``sqlmodel_ext.session`` imports
+    # ``sqlalchemy.ext.asyncio`` at module level, and SQLAlchemy 2.1 made greenlet optional.
+    "sqlalchemy[asyncio]>=2.0",
     # ``sqlmodel_ext.unset`` imports ``typing_extensions.Sentinel`` directly (to register
     # its deepcopy reducer); pydantic 2.12 already requires this floor transitively.
     "typing-extensions>=4.14.1",

{sqlmodel_ext-0.5.2 → sqlmodel_ext-0.5.3}/src/sqlmodel_ext/__init__.py

@@ -20,7 +20,7 @@ Quick start::
     user = await user.save(session)
     users = await User.get(session, fetch_mode="all")
 """
-__version__ = "0.5.2"
+__version__ = "0.5.3"
 
 # Every re-export below uses the redundant ``X as X`` form: the package ships
 # ``py.typed``, and type checkers treat a plain ``from m import X`` in a typed

{sqlmodel_ext-0.5.2 → sqlmodel_ext-0.5.3}/src/sqlmodel_ext/mixins/cached_table.py

@@ -265,7 +265,7 @@ _FORBIDDEN_DIRECT_CALLS: frozenset[str] = frozenset({
 
 
 def _on_outermost_transaction_end(session: _SyncSession, transaction: SessionTransaction) -> None:
-    """Clear the "tables with uncommitted writes" set when the outermost transaction ends.
+    """Clear the state that feeds the "uncommitted writes" check when the outermost transaction ends.
 
     ``transaction.parent is None`` is the *common exit* of commit / rollback /
     ``close()`` / ``reset()`` / ``invalidate()`` -- all of them dispatch this
@@ -276,12 +276,26 @@ def _on_outermost_transaction_end(session: _SyncSession, transaction: SessionTra
     cleanup always misses an entry point. Nested savepoints and the
     SUBTRANSACTION of a flush (``parent`` set) are ignored.
 
+    ``_SESSION_PENDING_CACHE_KEY`` is cleared here as well. Besides being the
+    list of pending invalidations, it is one of the three sources of
+    ``_tables_with_uncommitted_writes``: if it survives an ``invalidate()``,
+    every later ``get()`` on those tables skips the cache for as long as the
+    session is reused. On commit and on the outermost rollback,
+    ``after_commit`` / ``after_rollback`` have already popped it, so this is a
+    no-op there; ``invalidate()`` fires only this event.
+
+    Do **not** clear ``_SESSION_COMMITTED_PENDING_KEY`` here: the enhanced
+    ``commit()`` reads it after ``super().commit()`` returns, and this event
+    fires inside ``super().commit()``, right after ``after_commit``. Clearing
+    it here would drop the synchronous invalidation of every enhanced commit.
+
     Registered at import time (not by ``_register_session_commit_hook``):
     ``register_raw_dml_write`` fills the set for every session, cached models
     or not, so its lifetime must not depend on cache configuration.
     """
     if transaction.parent is None:
         session.info.pop(_SESSION_FLUSHED_TABLES, None)
+        session.info.pop(_SESSION_PENDING_CACHE_KEY, None)
 
 
 event.listen(_SyncSession, "after_transaction_end", _on_outermost_transaction_end)
@@ -2590,8 +2604,9 @@ class CachedTableBaseMixin(TableBaseMixin):
 
         This is **not** the common exit of transaction termination:
         ``close()`` / ``reset()`` do not dispatch ``after_rollback``, and the
-        async ``invalidate()`` bypasses them entirely. Transaction-level state
-        (such as ``_SESSION_FLUSHED_TABLES``) is therefore cleared in the
+        async ``invalidate()`` bypasses them entirely. State that feeds the
+        uncommitted-writes check (``_SESSION_FLUSHED_TABLES`` and
+        ``_SESSION_PENDING_CACHE_KEY``) is therefore cleared in the
         always-on ``_on_outermost_transaction_end`` listener -- do not
         add more keys here. The invalidation-tracking keys cleared here are
         normally consumed by ``after_commit`` / cleared by ``after_rollback``

{sqlmodel_ext-0.5.2 → sqlmodel_ext-0.5.3}/tests/test_cached_commit_paths.py

@@ -25,6 +25,7 @@ from sqlalchemy.ext.asyncio import AsyncEngine
 from sqlmodel.ext.asyncio.session import AsyncSession as PlainAsyncSession
 
 from sqlmodel_ext import AsyncSession, CachedTableBaseMixin, SQLModelBase, UUIDTableBaseMixin
+from sqlmodel_ext.mixins.cached_table import _SESSION_COMMITTED_PENDING_KEY
 
 FALLBACK_MESSAGE = "fallback compensation triggered"
 
@@ -102,6 +103,40 @@ async def test_enhanced_commit_invalidates_once_without_fallback_warning(
     assert await _version(fake_redis) == before + 1, "one commit must invalidate the query cache exactly once"
 
 
+@pytest.mark.asyncio
+async def test_enhanced_commit_preserves_handoff_until_transaction_end_listener_returns(
+    engine: AsyncEngine,
+    fake_redis: fakeredis.aioredis.FakeRedis,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """The outermost transaction-end listener must not erase the pending hand-off."""
+    gid = await _seed(engine, fake_redis)
+    caplog.set_level(logging.WARNING)
+    before = await _version(fake_redis)
+
+    async with AsyncSession(engine) as s:
+        observed_handoff: list[set[Any]] = []
+
+        def _capture_handoff_after_transaction_end(sync_session: Any, transaction: Any) -> None:
+            if transaction.parent is not None:
+                return
+            handed_over = sync_session.info.get(_SESSION_COMMITTED_PENDING_KEY)
+            observed_handoff.append(
+                set(handed_over.get(CommitPathGadget, set())) if isinstance(handed_over, dict) else set()
+            )
+
+        sa_event.listen(s.sync_session, 'after_transaction_end', _capture_handoff_after_transaction_end)
+        gadget = await _load(s, gid)
+        gadget.quantity = 2
+        await s.commit()
+        await _drain()
+
+    assert observed_handoff == [{gid}]
+    assert _fallback_records(caplog) == []
+    assert await fake_redis.exists(f"id:CommitPathGadget:{gid}") == 0
+    assert await _version(fake_redis) == before + 1, "one commit must invalidate the query cache exactly once"
+
+
 @pytest.mark.asyncio
 async def test_crud_commit_and_begin_block_have_no_fallback_warning(
     engine: AsyncEngine,

{sqlmodel_ext-0.5.2 → sqlmodel_ext-0.5.3}/tests/test_enhanced_session.py

@@ -34,6 +34,7 @@ from sqlmodel_ext.mixins.cached_table import (
     _SESSION_ENHANCED_COMMIT_KEY,
     _SESSION_FLUSHED_TABLES,
     _SESSION_PENDING_CACHE_KEY,
+    CachedTableBaseMixin,
 )
 from sqlmodel_ext.mixins.table import SESSION_REPEATABLE_READ_KEY
 from sqlmodel_ext.session import (
@@ -73,6 +74,26 @@ async def test_commit_plain_model_degrades_to_plain_commit(
     assert rows[0].name == "plain"
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize('boundary', ['commit', 'rollback', 'close', 'reset', 'invalidate'])
+async def test_transaction_boundary_clears_pending_write_tracking(
+    enhanced_session: AsyncSession,
+    boundary: str,
+) -> None:
+    """Every outermost transaction boundary must make pending writes invisible to the reused session."""
+    CachedTableBaseMixin._register_session_commit_hook()
+    enhanced_session.add(SessEntry(name='pending'))
+    await enhanced_session.flush()
+    enhanced_session.info[_SESSION_PENDING_CACHE_KEY] = {SessEntry: {1}}
+    assert CachedTableBaseMixin._tables_with_uncommitted_writes(enhanced_session)
+
+    boundary_method = getattr(enhanced_session, boundary)
+    await boundary_method()
+
+    assert _SESSION_PENDING_CACHE_KEY not in enhanced_session.info
+    assert CachedTableBaseMixin._tables_with_uncommitted_writes(enhanced_session) == set()
+
+
 @pytest.mark.asyncio
 async def test_reset_clears_tracking_state(enhanced_session: AsyncSession) -> None:
     enhanced_session.info[SESSION_FOR_UPDATE_KEY] = {123}