python-neva 2.2.0__py3-none-any.whl → 2.3.0__py3-none-any.whl

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)

neva/database/manager.py

@@ -10,6 +10,7 @@ from neva import Nothing, Option, Some
 from neva.database.connection import ConnectionManager, TransactionContext
 from neva.database.transaction import BoundTransaction, Transaction
 from neva.obs import LogManager
+from neva.obs.instrumentation.sqlalchemy import instrument
 
 
 @final
@@ -30,6 +31,7 @@ class DatabaseManager:
             name: The connection name.
             engine: The async engine.
         """
+        instrument(engine)
         self._engines[name] = engine
         self._session_factories[name] = async_sessionmaker(
             bind=engine,
@@ -60,15 +62,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 +104,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

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

neva/obs/instrumentation/__init__.py

@@ -0,0 +1 @@
+"""Various OTel instrumentation."""

neva/obs/instrumentation/sqlalchemy.py

@@ -0,0 +1,15 @@
+"""SQLAlchemy instrumentation."""
+
+from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
+from sqlalchemy import Engine
+from sqlalchemy.ext.asyncio import AsyncEngine
+
+
+def instrument(engine: AsyncEngine | Engine) -> None:
+    """Instrument SQLAlchemy engine."""
+    match engine:
+        case AsyncEngine():
+            to_instrument = engine.sync_engine
+        case Engine():
+            to_instrument = engine
+    SQLAlchemyInstrumentor().instrument(engine=to_instrument)

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.dist-info → python_neva-2.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-neva
-Version: 2.2.0
+Version: 2.3.0
 Summary: Add your description here
 Requires-Python: >=3.12
 Requires-Dist: aiosqlite>=0.20.0
@@ -9,6 +9,7 @@ Requires-Dist: cryptography>=46.0.3
 Requires-Dist: dishka>=1.7.2
 Requires-Dist: fastapi[all]>=0.129.0
 Requires-Dist: faststream>=0.6.6
+Requires-Dist: opentelemetry-instrumentation-sqlalchemy>=0.62b0
 Requires-Dist: pwdlib[argon2,bcrypt]>=0.3.0
 Requires-Dist: pyinstrument>=5.1.1
 Requires-Dist: sqlalchemy[asyncio]>=2.0.0

{python_neva-2.2.0.dist-info → python_neva-2.3.0.dist-info}/RECORD

@@ -13,10 +13,10 @@ neva/config/loader.py,sha256=ZIcx8oYIi2r4wv1G_Q7_a6nG7wARyzjiZ2wF43t3B2I,3942
 neva/config/repository.py,sha256=B7iWgJLtOIwdmp7I0y9ISgl3g_Xc60tUe-ofDUKM6fg,4827
 neva/database/__init__.py,sha256=3yYnEe8HQM86tURyAhTbMtE7AXubIEMN3GuwxkkT-bk,508
 neva/database/config.py,sha256=bVKUqlrYDFrURqg_FbntPXyVkbOUPSVXQJTKjyucjL0,451
-neva/database/connection.py,sha256=yVosFiZWTOircIUKBewXI6Cksbh5hwx6dVitsF0QWhc,7013
-neva/database/manager.py,sha256=OwArEKGmjjPPj5iGNm8Fg8rq-jtnwAiHAqLbBAp_oG8,3947
+neva/database/connection.py,sha256=et1fvGxa2iHTJ8yzAv9VIYqfD4GtGaV0KQUW97SdLHQ,7107
+neva/database/manager.py,sha256=tQFHj2HZzo3oxdWyWNQlv5277I7vh7vDlEEiUyAKjDs,4511
 neva/database/provider.py,sha256=R-K4aFCgF8Ewu6I_-BXo874IYgQgI3b8qYPsGe7ArFA,1785
-neva/database/transaction.py,sha256=vZR7nUuQbkuFcxA07wBUOalY6ilz7NwmLWKCNQmnkXU,4321
+neva/database/transaction.py,sha256=yQuFDhdXipUWac3zx4rVy6R6XUB_xPT_CLoQ-26223Y,5933
 neva/events/__init__.py,sha256=xwIAXNcOASpuCY4DJpshZc1gtxQHimzwy-s7c-4QuiQ,746
 neva/events/dispatcher.py,sha256=3xMhxE5uQBY7648jp75NkRwu09lqYo7ymmfSvnl6kT0,2850
 neva/events/event.py,sha256=g3vAx-2qiR3QRM_or8G9mK5qx66A2LZiZ3n517R4lGQ,251
@@ -24,6 +24,8 @@ neva/events/event_registry.py,sha256=jucYOUjCERz-ICdPiDrxYw_ySvmPJOcRzYKCgka29qY
 neva/events/listener.py,sha256=AMfi24R_WA_-mVg0fxfOrwY6EV8kO1wU5YpAFPvGrus,1825
 neva/events/provider.py,sha256=ilPW_-zaLMrh-cgWphLe_aqvs00LNp93OOMFFpIppyE,767
 neva/obs/__init__.py,sha256=dVzgljk9Hvo44LI34RcwbDyT42_z4nSnFVmL4GLbKD0,331
+neva/obs/instrumentation/__init__.py,sha256=SfIAvuCs-L0kEzOxUJ4aOIkhbydCe7qBwWtGeDELVA0,36
+neva/obs/instrumentation/sqlalchemy.py,sha256=kwk43NthFi4mPMhDJI55rxt9YPOY_mwOkr2E-cD64ZY,497
 neva/obs/logging/__init__.py,sha256=gIYBAzMK7-wPGEpA_kYKvJPT3hYN99OcCc9UuHFeiHk,251
 neva/obs/logging/manager.py,sha256=ktd3muBGU3e1KuBK6tSU5faRJRliPwmknuqJ2EYeFBk,2422
 neva/obs/logging/provider.py,sha256=lt5oma5eV6mjN4C5iFhyYf0BmI9BMbFVBJJNSy2XOkg,638
@@ -71,7 +73,7 @@ neva/testing/__init__.py,sha256=vt5zxG1N84vn_YwP44jhYPWYnyb02-cha3m-1l-qoEw,207
 neva/testing/fakes.py,sha256=ffAAZC7WymuutVYk3vefuPDUvpNHav2QV2lj-Gw0Kic,2666
 neva/testing/fixtures.py,sha256=-l_Drw6nXTD_cKpfg1Z1pmsXnaD3NM2kihdRHxSkfzE,1657
 neva/testing/http.py,sha256=9oKNzaz38nCKkL-ZUF5CRWFPqpNmXkqbYcoukC509_Q,494
-neva/testing/test_case.py,sha256=8ag24TpvOhrr0Vgwq1j5NO_ASYwWJzhOq-wH26DhbDs,3302
-python_neva-2.2.0.dist-info/METADATA,sha256=H5ABzyvGdhskuZvxWy-7wLsBnVwRQ3ZXUV0KZ30i6Vc,627
-python_neva-2.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-python_neva-2.2.0.dist-info/RECORD,,
+neva/testing/test_case.py,sha256=FzXBHctkVkFNu46S5lnt7iRX91TLPLfL1Lzgn-iU-_E,3325
+python_neva-2.3.0.dist-info/METADATA,sha256=woz2CCGwVG7vPpl7C6tGjv2634D5iwO4WPeXzrPk8mw,691
+python_neva-2.3.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_neva-2.3.0.dist-info/RECORD,,