fastapi-toolsets 5.1.3__tar.gz → 5.1.4__tar.gz

{fastapi_toolsets-5.1.3 → fastapi_toolsets-5.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-toolsets
-Version: 5.1.3
+Version: 5.1.4
 Summary: Production-ready utilities for FastAPI applications
 Keywords: fastapi,sqlalchemy,postgresql
 Author: d3vyce

{fastapi_toolsets-5.1.3 → fastapi_toolsets-5.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-toolsets"
-version = "5.1.3"
+version = "5.1.4"
 description = "Production-ready utilities for FastAPI applications"
 readme = "README.md"
 license = "MIT"

{fastapi_toolsets-5.1.3 → fastapi_toolsets-5.1.4}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-toolsets"
-version = "5.1.3"
+version = "5.1.4"
 description = "Production-ready utilities for FastAPI applications"
 readme = "README.md"
 license = "MIT"

{fastapi_toolsets-5.1.3 → fastapi_toolsets-5.1.4}/src/fastapi_toolsets/__init__.py

@@ -24,4 +24,4 @@ Example usage:
         return Response(data={"user": user.username}, message="Success")
 """
 
-__version__ = "5.1.3"
+__version__ = "5.1.4"

{fastapi_toolsets-5.1.3 → fastapi_toolsets-5.1.4}/src/fastapi_toolsets/models/watched.py

@@ -1,13 +1,15 @@
 """Field-change monitoring via SQLAlchemy session events."""
 
 import inspect
-from collections.abc import Callable
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
 from enum import Enum
 from typing import Any
 
 from sqlalchemy import event, select, tuple_
 from sqlalchemy import inspect as sa_inspect
-from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.ext.asyncio import AsyncSession, AsyncSessionTransaction
+from sqlalchemy.ext.asyncio import async_session as _async_session
 from sqlalchemy.orm import selectinload
 from sqlalchemy.orm.attributes import set_committed_value as _sa_set_committed_value
 
@@ -25,9 +27,11 @@ class ModelEvent(str, Enum):
 
 
 _CALLBACK_ERROR_MSG = "Event callback raised an unhandled exception"
+_RELOAD_TRANSACTION_ERROR_MSG = "Closing the post-commit reload transaction failed"
 _SESSION_CREATES = "_ft_creates"
 _SESSION_DELETES = "_ft_deletes"
 _SESSION_UPDATES = "_ft_updates"
+_SESSION_PRELOADED = "_ft_preloaded"
 _DEFERRED_STRATEGY_KEY = (("deferred", True), ("instrument", True))
 _EVENT_HANDLERS: dict[tuple[type, ModelEvent], list[Callable[..., Any]]] = {}
 _HANDLER_CACHE: dict[tuple[type, ModelEvent], list[Callable[..., Any]]] = {}
@@ -126,12 +130,24 @@ def _upsert_changes(
         pending[key] = (obj, changes)
 
 
+def _dispatches(session: Any) -> bool:
+    """True when *session* is driven by an :class:`EventSession`."""
+    return isinstance(_async_session(session), EventSession)
+
+
 @event.listens_for(AsyncSession.sync_session_class, "after_flush")
 def _after_flush(session: Any, flush_context: Any) -> None:
+    if _dispatches(session):
+        _collect(session)
+
+
+def _collect(session: Any) -> None:
+    """Record the flushed changes that the next commit will dispatch."""
     # New objects: capture reference. Attributes will be refreshed after commit.
     for obj in session.new:
         if _get_handlers(type(obj), ModelEvent.CREATE):
             session.info.setdefault(_SESSION_CREATES, []).append(obj)
+            _record_loaded_relationships(session, obj)
 
     # Deleted objects: snapshot now while attributes are still loaded.
     for obj in session.deleted:
@@ -170,6 +186,7 @@ def _after_flush(session: Any, flush_context: Any) -> None:
                 obj,
                 changes,
             )
+            _record_loaded_relationships(session, obj)
 
 
 @event.listens_for(AsyncSession.sync_session_class, "after_rollback")
@@ -179,6 +196,7 @@ def _after_rollback(session: Any) -> None:
     session.info.pop(_SESSION_CREATES, None)
     session.info.pop(_SESSION_DELETES, None)
     session.info.pop(_SESSION_UPDATES, None)
+    session.info.pop(_SESSION_PRELOADED, None)
 
 
 async def _invoke_callback(
@@ -208,7 +226,9 @@ async def _dispatch(
 
 def _loaded_relationships(obj: Any) -> set[str]:
     """Relationship keys currently loaded on *obj*."""
-    state = sa_inspect(obj)
+    state = sa_inspect(obj, raiseerr=False)
+    if state is None:
+        return set()
     unloaded = state.unloaded
     return {
         rel.key
@@ -217,11 +237,38 @@ def _loaded_relationships(obj: Any) -> set[str]:
     }
 
 
+def _record_loaded_relationships(session: Any, obj: Any) -> None:
+    """Merge the relationships loaded on *obj* into the session's record."""
+    store: dict[int, set[str]] = session.info.setdefault(_SESSION_PRELOADED, {})
+    store.setdefault(id(obj), set()).update(_loaded_relationships(obj))
+
+
 def _snapshot_loaded_relationships(session: Any) -> dict[int, set[str]]:
-    """Record loaded relationships for the tracked objects, keyed by ``id``."""
+    """Loaded relationships for the tracked objects, keyed by ``id``."""
+    snapshot = {
+        key: set(value)
+        for key, value in session.info.get(_SESSION_PRELOADED, {}).items()
+    }
     objs = list(session.info.get(_SESSION_CREATES, []))
     objs += [obj for obj, _ in session.info.get(_SESSION_UPDATES, {}).values()]
-    return {id(obj): _loaded_relationships(obj) for obj in objs}
+    for obj in objs:
+        snapshot.setdefault(id(obj), set()).update(_loaded_relationships(obj))
+    return snapshot
+
+
+@contextmanager
+def _suspended_trans_ctx(session: AsyncSession) -> Iterator[None]:
+    """Allow post-commit SQL while an outer ``session.begin()`` block is open."""
+    sync_session = session.sync_session
+    ctx = getattr(sync_session, "_trans_context_manager", None)
+    if ctx is None:
+        yield
+        return
+    sync_session._trans_context_manager = None
+    try:
+        yield
+    finally:
+        sync_session._trans_context_manager = ctx
 
 
 async def _batch_reload(
@@ -247,13 +294,47 @@ async def _batch_reload(
     await session.execute(q)
 
 
+class _EventSessionTransaction(AsyncSessionTransaction):
+    """Transaction context manager that dispatches on a real commit."""
+
+    __slots__ = ()
+
+    async def __aexit__(self, type_: object, value: object, traceback: object) -> None:
+        session = self.session
+        commits = (
+            type_ is None
+            and not self.nested
+            and isinstance(session, EventSession)
+            and self.is_active
+        )
+        preloaded = _snapshot_loaded_relationships(session) if commits else {}
+        await super().__aexit__(type_, value, traceback)
+        if commits:
+            await session._dispatch_pending(preloaded)
+
+
 class EventSession(AsyncSession):
     """AsyncSession subclass that dispatches lifecycle callbacks after commit."""
 
+    def begin(self) -> AsyncSessionTransaction:
+        """Return a transaction context manager that dispatches on commit."""
+        return _EventSessionTransaction(self)
+
+    def begin_nested(self) -> AsyncSessionTransaction:
+        """Return a savepoint context manager; events wait for the real commit."""
+        return _EventSessionTransaction(self, nested=True)
+
     async def commit(self) -> None:
         preloaded = _snapshot_loaded_relationships(self)
         await super().commit()
-
+        await self._dispatch_pending(preloaded)
+
+    async def _dispatch_pending(self, preloaded: dict[int, set[str]]) -> None:
+        """Run the callbacks collected for the transaction that just committed."""
+        # The commit itself flushes, so objects first collected there are only
+        # recorded now; merge them into the pre-commit snapshot.
+        for key, value in self.info.pop(_SESSION_PRELOADED, {}).items():
+            preloaded.setdefault(key, set()).update(value)
         creates: list[Any] = self.info.pop(_SESSION_CREATES, [])
         deletes: list[tuple[Any, dict[str, Any]]] = self.info.pop(_SESSION_DELETES, [])
         field_changes: dict[int, tuple[Any, dict[str, dict[str, Any]]]] = self.info.pop(
@@ -310,32 +391,49 @@ class EventSession(AsyncSession):
             update_items.append((obj, changes))
             objs_by_type.setdefault(type(obj), []).append(obj)
 
-        for model, objs in objs_by_type.items():
-            try:
-                await _batch_reload(self, model, objs, preloaded)
-            except Exception as exc:
-                _logger.error(_CALLBACK_ERROR_MSG, exc_info=exc)
-
-        # Dispatch CREATE callbacks.
-        for obj in create_items:
-            await _dispatch(obj, ModelEvent.CREATE, None)
-
-        # Dispatch DELETE callbacks (restore snapshot; row is gone).
-        for obj, snapshot in deletes:
-            try:
-                for key, value in snapshot.items():
-                    _sa_set_committed_value(obj, key, value)
-            except Exception as exc:
-                _logger.error(_CALLBACK_ERROR_MSG, exc_info=exc)
-                continue
-            await _dispatch(obj, ModelEvent.DELETE, None)
-
-        # Dispatch UPDATE callbacks.
-        for obj, changes in update_items:
-            await _dispatch(obj, ModelEvent.UPDATE, changes)
+        with _suspended_trans_ctx(self):
+            had_transaction = self.in_transaction()
+            for model, objs in objs_by_type.items():
+                try:
+                    await _batch_reload(self, model, objs, preloaded)
+                except Exception as exc:
+                    _logger.error(_CALLBACK_ERROR_MSG, exc_info=exc)
+            if not had_transaction and self.in_transaction():
+                await self._end_reload_transaction()
+
+            # Dispatch CREATE callbacks.
+            for obj in create_items:
+                await _dispatch(obj, ModelEvent.CREATE, None)
+
+            # Dispatch DELETE callbacks (restore snapshot; row is gone).
+            for obj, snapshot in deletes:
+                try:
+                    for key, value in snapshot.items():
+                        _sa_set_committed_value(obj, key, value)
+                except Exception as exc:
+                    _logger.error(_CALLBACK_ERROR_MSG, exc_info=exc)
+                    continue
+                await _dispatch(obj, ModelEvent.DELETE, None)
+
+            # Dispatch UPDATE callbacks.
+            for obj, changes in update_items:
+                await _dispatch(obj, ModelEvent.UPDATE, changes)
+
+    async def _end_reload_transaction(self) -> None:
+        """Commit the read-only transaction the reload opened, keeping state loaded."""
+        sync_session = self.sync_session
+        expire_on_commit = sync_session.expire_on_commit
+        sync_session.expire_on_commit = False
+        try:
+            await super().commit()
+        except Exception as exc:
+            _logger.error(_RELOAD_TRANSACTION_ERROR_MSG, exc_info=exc)
+        finally:
+            sync_session.expire_on_commit = expire_on_commit
 
     async def rollback(self) -> None:
         await super().rollback()
         self.info.pop(_SESSION_CREATES, None)
         self.info.pop(_SESSION_DELETES, None)
         self.info.pop(_SESSION_UPDATES, None)
+        self.info.pop(_SESSION_PRELOADED, None)