python-neva 2.2.0__tar.gz → 2.2.1__tar.gz

{python_neva-2.2.0 → python_neva-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-neva
-Version: 2.2.0
+Version: 2.2.1
 Summary: Add your description here
 Requires-Python: >=3.12
 Requires-Dist: aiosqlite>=0.20.0

{python_neva-2.2.0 → python_neva-2.2.1}/neva/database/connection.py

@@ -152,11 +152,11 @@ class ConnectionManager:
         For nested calls on the same connection, reuses the parent session
         and begins a savepoint instead of a full transaction.
 
-        Raises:
-            RuntimeError: If no engine has been registered for this connection.
-
         Yields:
             BoundTransaction: A transaction with a guaranteed non-null session.
+
+        Raises:
+            RuntimeError: If no engine has been registered for this connection.
         """
         if self.session_factory is None:
             raise RuntimeError(
@@ -167,7 +167,10 @@ class ConnectionManager:
         parent = self.tx_context.current(self.name)
 
         match parent:
-            case Some(parent_tx) if isinstance(parent_tx, BoundTransaction):
+            case Some(parent_tx) if (
+                isinstance(parent_tx, BoundTransaction)
+                and parent_tx.is_accessible_from_current_task
+            ):
                 tx = Transaction(self.name)
                 tx.parent = parent
                 bound = tx.begin(parent_tx.session)

{python_neva-2.2.0 → python_neva-2.2.1}/neva/database/manager.py

@@ -60,15 +60,24 @@ class DatabaseManager:
     def session(self, connection: str | None = None) -> Option[AsyncSession]:
         """Returns the current session for a connection.
 
+        Only returns a session if the active transaction was opened by the
+        current asyncio task. Transactions inherited from a parent task
+        (e.g. via context propagation in Strawberry GraphQL resolvers) are
+        not accessible this way — each task must call ``begin()`` to obtain
+        its own session.
+
         Args:
             connection: The connection name. Defaults to "default".
 
         Returns:
             The current session, if any. Returns Nothing if there is no active
-            bound transaction on the given connection.
+            bound transaction on the given connection, or if the active
+            transaction was opened by a different asyncio task.
         """
         match self.current(connection):
-            case Some(tx) if isinstance(tx, BoundTransaction):
+            case Some(tx) if (
+                isinstance(tx, BoundTransaction) and tx.is_accessible_from_current_task
+            ):
                 return Some(tx.session)
             case _:
                 return Nothing()
@@ -93,11 +102,11 @@ class DatabaseManager:
         Args:
             name: The connection name.
 
-        Raises:
-            RuntimeError: If no engine has been registered for the connection.
-
         Yields:
             BoundTransaction: A transaction with a guaranteed non-null session.
+
+        Raises:
+            RuntimeError: If no engine has been registered for the connection.
         """  # noqa: DOC502 explicit documentation of the possible exception raised by 'begin'
         async with self.connection(name).begin() as tx:
             yield tx

{python_neva-2.2.0 → python_neva-2.2.1}/neva/database/transaction.py

@@ -1,5 +1,6 @@
 """Transaction management systems."""
 
+import asyncio
 from collections.abc import Awaitable
 from dataclasses import dataclass, field
 from enum import Enum, auto
@@ -128,3 +129,39 @@ class BoundTransaction(Transaction):
     """Transaction bound to an SQLAlchemy session."""
 
     session: AsyncSession
+    _owning_task: asyncio.Task[object] | None = field(default=None, init=False)
+    _shared: bool = field(default=False, init=False)
+
+    def __post_init__(self) -> None:
+        """Capture the current asyncio task as the owner of this transaction."""
+        self._owning_task = asyncio.current_task()
+
+    def share(self) -> None:
+        """Allow any asyncio task to access this transaction's session.
+
+        By default, a transaction is only accessible from the task that
+        created it. Calling this method lifts that restriction, allowing
+        other tasks that inherited the transaction context to use the same
+        session.
+
+        This is intended for controlled sequential-access patterns such as
+        test isolation wrappers (e.g. ``RefreshDatabase``) where a fixture
+        opens a transaction and the test body runs inside it. It must
+        **not** be used when multiple tasks may access the session
+        concurrently, as ``AsyncSession`` is not concurrent-safe.
+        """
+        self._shared = True
+
+    @property
+    def is_accessible_from_current_task(self) -> bool:
+        """Return True if the current asyncio task may use this transaction's session.
+
+        Returns:
+            True if the transaction was created by the current task, or if
+            ``share()`` has been called. False if called from a different
+            task without sharing, or from outside any async task.
+        """
+        if self._shared:
+            return True
+        current = asyncio.current_task()
+        return current is not None and current is self._owning_task

{python_neva-2.2.0 → python_neva-2.2.1}/neva/testing/test_case.py

@@ -97,5 +97,6 @@ class RefreshDatabase:
         """Wrap the test in a DB transaction and roll it back on completion."""
         db = _test_case_application.make(DatabaseManager).unwrap()
         async with db.begin() as tx:
+            tx.share()
             yield
             await tx.rollback()

{python_neva-2.2.0 → python_neva-2.2.1}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["neva"]
 
 [project]
 name = "python-neva"
-version = "2.2.0"
+version = "2.2.1"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"

{python_neva-2.2.0 → python_neva-2.2.1}/tests/database/test_sqlalchemy_integration.py

@@ -1,5 +1,6 @@
 """SQLAlchemy integration tests with real in-memory SQLite."""
 
+import asyncio
 from collections.abc import AsyncIterator
 from typing import final
 
@@ -177,3 +178,137 @@ class TestDatabaseManagerClose:
 
         manager_after = db.connection("default")
         assert manager_before is not manager_after
+
+
+class TestConcurrentTaskIsolation:
+    async def test_session_not_visible_from_different_task(
+        self, db: DatabaseManager
+    ) -> None:
+        result: list[bool] = []
+
+        async with db.begin():
+
+            async def child() -> None:
+                result.append(db.session().is_some)
+
+            await asyncio.create_task(child())
+
+        assert result == [False]
+
+    async def test_session_visible_from_same_task(self, db: DatabaseManager) -> None:
+        async with db.begin() as tx:
+            assert db.session().is_some
+            assert db.session().unwrap() is tx.session
+
+    async def test_begin_from_different_task_creates_new_session(
+        self, db: DatabaseManager
+    ) -> None:
+        outer_session_id: list[int] = []
+        inner_session_id: list[int] = []
+
+        async with db.begin() as outer:
+            outer_session_id.append(id(outer.session))
+
+            async def child() -> None:
+                async with db.begin() as inner:
+                    inner_session_id.append(id(inner.session))
+
+            await asyncio.create_task(child())
+
+        assert outer_session_id[0] != inner_session_id[0]
+
+    async def test_begin_from_different_task_has_no_parent(
+        self, db: DatabaseManager
+    ) -> None:
+        parent_set: list[bool] = []
+
+        async with db.begin():
+
+            async def child() -> None:
+                async with db.begin() as tx:
+                    parent_set.append(tx.parent.is_some)
+
+            await asyncio.create_task(child())
+
+        assert parent_set == [False]
+
+    async def test_concurrent_tasks_get_distinct_sessions(
+        self, db: DatabaseManager
+    ) -> None:
+        session_ids: list[int] = []
+
+        async with db.begin():
+
+            async def task_work() -> None:
+                async with db.begin() as tx:
+                    session_ids.append(id(tx.session))
+
+            _ = await asyncio.gather(
+                asyncio.create_task(task_work()),
+                asyncio.create_task(task_work()),
+                asyncio.create_task(task_work()),
+            )
+
+        assert len(session_ids) == 3
+        assert len(set(session_ids)) == 3
+
+    async def test_concurrent_reads_do_not_raise(self, db: DatabaseManager) -> None:
+        errors: list[Exception] = []
+
+        async with db.begin():
+
+            async def resolver() -> None:
+                try:
+                    async with db.begin() as tx:
+                        _ = await tx.session.execute(select(User))
+                except Exception as exc:
+                    errors.append(exc)
+
+            _ = await asyncio.gather(
+                asyncio.create_task(resolver()),
+                asyncio.create_task(resolver()),
+                asyncio.create_task(resolver()),
+            )
+
+        assert not errors, f"Unexpected errors: {errors}"
+
+    async def test_nested_begin_same_task_still_uses_savepoint(
+        self, db: DatabaseManager
+    ) -> None:
+        async with db.begin() as outer, db.connection("default").begin() as inner:
+            assert inner.session is outer.session
+            assert inner.parent.is_some
+
+    async def test_shared_transaction_is_visible_from_different_task(
+        self, db: DatabaseManager
+    ) -> None:
+        result: list[bool] = []
+
+        async with db.begin() as tx:
+            tx.share()
+
+            async def child() -> None:
+                result.append(db.session().is_some)
+
+            await asyncio.create_task(child())
+
+        assert result == [True]
+
+    async def test_shared_transaction_child_begin_creates_savepoint(
+        self, db: DatabaseManager
+    ) -> None:
+        inner_parent_set: list[bool] = []
+        same_session: list[bool] = []
+
+        async with db.begin() as outer:
+            outer.share()
+
+            async def child() -> None:
+                async with db.begin() as inner:
+                    inner_parent_set.append(inner.parent.is_some)
+                    same_session.append(inner.session is outer.session)
+
+            await asyncio.create_task(child())
+
+        assert inner_parent_set == [True]
+        assert same_session == [True]

{python_neva-2.2.0 → python_neva-2.2.1}/uv.lock

@@ -1438,7 +1438,7 @@ wheels = [
 
 [[package]]
 name = "python-neva"
-version = "2.2.0"
+version = "2.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "aiosqlite" },