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

{python_neva-2.1.0 → python_neva-2.2.1}/.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/gitleaks/gitleaks
-    rev: v8.24.2
+    rev: v8.30.1
     hooks:
       - id: gitleaks
 
@@ -16,16 +16,13 @@ repos:
       - id: debug-statements
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.13.3
+    rev: v0.15.6
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]
       - id: ruff-format
 
-  - repo: local
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.19.1
     hooks:
-      - id: ty
-        name: ty check
-        entry: ty check . --project neva
-        files: ^neva/
-        language: system
+      - id: mypy

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

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

{python_neva-2.1.0 → python_neva-2.2.1}/neva/arch/app.py

@@ -13,6 +13,7 @@ from typing import Any, Callable
 import dishka
 import fastapi
 from dishka.integrations.fastapi import setup_dishka
+from starlette.middleware import Middleware
 from starlette.routing import BaseRoute
 from starlette.types import StatefulLifespan, StatelessLifespan
 
@@ -28,7 +29,7 @@ class App(fastapi.FastAPI):
         self,
         *,
         routes: list[BaseRoute] | None = None,
-        middlewares: Sequence[type] | None = None,
+        middlewares: Sequence[Middleware] | None = None,
         lifespan: StatelessLifespan["App"] | StatefulLifespan["App"] | None = None,
         config_path: str | Path | None = None,
     ) -> None:
@@ -58,9 +59,8 @@ class App(fastapi.FastAPI):
             docs_url=config.get("app.docs_url", default="/docs").unwrap(),
             redoc_url=config.get("app.redoc_url", default="/redoc").unwrap(),
             lifespan=self._create_lifespan(),
+            middleware=middlewares,
         )
-        for middleware in middlewares or []:
-            self.add_middleware(middleware)
 
         setup_dishka(self.application.container, app=self)
 

{python_neva-2.1.0 → python_neva-2.2.1}/neva/arch/application.py

@@ -12,6 +12,7 @@ from dishka.integrations.fastapi import FastapiProvider
 from neva import Err, Ok, Result
 from neva.arch.facade import Facade
 from neva.arch.service_provider import Bootable, ServiceProvider
+from neva.config.loader import ConfigLoader
 
 
 class Application:
@@ -28,45 +29,38 @@ class Application:
             RuntimeError: If the application fails to initialize.
         """
         from neva.config.base_providers import base_providers
-        from neva.config.provider import ConfigServiceProvider
         from neva.config.repository import ConfigRepository
 
+        self.config: ConfigRepository = ConfigRepository()
         self.providers: dict[type, ServiceProvider] = {}
         self.di_provider: dishka.Provider = dishka.Provider(scope=dishka.Scope.APP)
 
-        configuration_path = config_path or os.getenv("NEVA_CONFIG_PATH", default=None)
-        config_provider = ConfigServiceProvider(
-            app=self,
-            config_path=configuration_path,
-        ).register()
-        if config_provider.is_err:
-            raise RuntimeError(
-                f"Failed to register config provider: {config_provider.unwrap_err()}"
-            )
-        self.providers[ConfigServiceProvider] = config_provider.unwrap()
-
-        self.register_providers(base_providers())
-        _ = self.di_provider.provide(source=lambda: self, provides=Application)
-
-        self.container: dishka.Container = dishka.make_container(self.di_provider)
-
-        config_result: Result[ConfigRepository, str] = self.make(
-            interface=ConfigRepository
+        configuration_path = (
+            config_path
+            if config_path is not None
+            else os.getenv("NEVA_CONFIG_PATH", default=Path.cwd())
         )
-        match config_result:
-            case Ok(config):
-                self.config: ConfigRepository = config
-                providers_from_file = config.get("providers.providers").unwrap_or([])
-                providers_from_app = config.get("app.providers").unwrap_or([])
-                providers: set[type[ServiceProvider]] = set(providers_from_file).union(
-                    set(providers_from_app)
-                )
-                _ = self.register_providers(providers)
+        match ConfigLoader(configuration_path).load_all():
             case Err(e):
-                raise RuntimeError(f"Failed to load configuration during boot: {e}")
-
+                raise RuntimeError(f"Failed to register config: {e}")
+            case Ok(configs):
+                if any(
+                    self.config.merge(namespace, config).is_err
+                    for namespace, config in configs.items()
+                ):
+                    raise RuntimeError("Failed to register config")
+
+                self.bind(lambda: self.config, interface=ConfigRepository)
+
+        providers_from_file = self.config.get("providers.providers").unwrap_or([])
+        providers_from_app = self.config.get("app.providers").unwrap_or([])
+        providers: set[type[ServiceProvider]] = set(providers_from_file).union(
+            set(providers_from_app)
+        )
+        self.register_providers(base_providers().union(providers))
+        self.bind(source=lambda: self, interface=Application)
         self._bind_event_listeners()
-        self.container = dishka.make_container(self.di_provider)
+        self.container: dishka.Container = dishka.make_container(self.di_provider)
 
     def bind_to_fastapi(self) -> None:
         """Setup the FastapiProvider for FastAPI integration."""

{python_neva-2.1.0 → python_neva-2.2.1}/neva/arch/facade.py

@@ -8,7 +8,7 @@ injection container, enabling convenient access without explicit dependency inje
 from abc import ABC, ABCMeta, abstractmethod
 from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, ClassVar
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 from unittest.mock import AsyncMock, MagicMock
 
 from neva import Ok, Option, Result, from_optional
@@ -150,8 +150,12 @@ class FacadeMeta(ABCMeta):
             The MagicMock spy installed as the facade root.
 
         """
-        app = cls._get_app().ok_or(f"Cannot spy on {cls.__name__}: no application set.")
-        real = app.and_then(lambda a: a.make(cls.get_facade_accessor())).unwrap()
+        real: object = (
+            cls._get_app()
+            .ok_or(f"Cannot spy on {cls.__name__}: no application set.")
+            .and_then(lambda a: a.make(cls.get_facade_accessor()))
+            .unwrap()
+        )
         spy_obj = MagicMock(spec=type(real), wraps=real)
         cls.swap(spy_obj)
         return spy_obj
@@ -193,7 +197,7 @@ class FacadeMeta(ABCMeta):
 
         """
         if cls in FacadeMeta._fake_instances:
-            return Ok(FacadeMeta._fake_instances[cls])
+            return Ok(cast(T, FacadeMeta._fake_instances[cls]))
         return app.make(interface)
 
 

{python_neva-2.1.0 → python_neva-2.2.1}/neva/config/__init__.py

@@ -1,10 +1,8 @@
 """Configuration system."""
 
-from neva.config.provider import ConfigServiceProvider
 from neva.config.repository import ConfigRepository
 
 
 __all__ = [
     "ConfigRepository",
-    "ConfigServiceProvider",
 ]

{python_neva-2.1.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.1.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.1.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.1.0 → python_neva-2.2.1}/neva/security/encryption/encrypter.py

@@ -51,7 +51,9 @@ class AesEncrypter:
         Returns:
             Ok with base64-encoded encrypted payload, or Err with message.
         """
-        wrapper = {"__str__": value} if isinstance(value, str) else {"__json__": value}
+        wrapper: dict[str, JsonValue] = (
+            {"__str__": value} if isinstance(value, str) else {"__json__": value}
+        )
 
         try:
             payload = json.dumps(wrapper)

{python_neva-2.1.0 → python_neva-2.2.1}/neva/support/results.py

@@ -246,7 +246,7 @@ class OptionProtocol[T](ABC):
 
 
 @dataclass(eq=True, frozen=True)
-class Some(OptionProtocol[T]):
+class Some[T](OptionProtocol[T]):
     """An Option containing a value.
 
     Represents the presence of a value in an Option type. All transformation
@@ -330,7 +330,7 @@ class Some(OptionProtocol[T]):
 
 
 @dataclass(eq=True, frozen=True)
-class Nothing(OptionProtocol[T]):
+class Nothing[T](OptionProtocol[T]):
     """An Option containing no value.
 
     Represents the absence of a value in an Option type. All transformation
@@ -594,7 +594,7 @@ class ResultProtocol[T, E](ABC):
 
 
 @dataclass(eq=True, frozen=True)
-class Ok(ResultProtocol[T, E]):
+class Ok[T, E](ResultProtocol[T, E]):
     """A Result containing a success value.
 
     Represents a successful operation in a Result type. All transformation
@@ -671,7 +671,7 @@ class Ok(ResultProtocol[T, E]):
 
 
 @dataclass(eq=True, frozen=True)
-class Err(ResultProtocol[T, E]):
+class Err[T, E](ResultProtocol[T, E]):
     """A Result containing an error value.
 
     Represents a failed operation in a Result type. All transformation methods

{python_neva-2.1.0 → python_neva-2.2.1}/neva/testing/fixtures.py

@@ -1,9 +1,8 @@
 """Fixtures for testing."""
 
 from collections.abc import AsyncIterator, Callable
-from contextlib import asynccontextmanager
+from contextlib import AbstractAsyncContextManager, asynccontextmanager
 from pathlib import Path
-from typing import AsyncContextManager
 
 import pytest
 
@@ -45,7 +44,7 @@ def webapp(test_config: Path) -> App:
 
 
 @pytest.fixture
-def app_factory() -> Callable[[Path], AsyncContextManager[Application]]:
+def app_factory() -> Callable[[Path], AbstractAsyncContextManager[Application]]:
     """Factory fixture for creating applications with custom configs.
 
     Returns:

{python_neva-2.1.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.1.0 → python_neva-2.2.1}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["neva"]
 
 [project]
 name = "python-neva"
-version = "2.1.0"
+version = "2.2.1"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -31,6 +31,7 @@ testing = ["pytest>=9.0.2", "pytest-asyncio>=0.25.3"]
 [dependency-groups]
 dev = [
   "bandit>=1.9.2",
+  "mypy>=1.19.1",
   "poethepoet>=0.38.0",
   "polyfactory>=3.1.0",
   "pre-commit>=4.5.0",
@@ -38,8 +39,7 @@ dev = [
   "pytest-asyncio>=0.25.3",
   "pytest-benchmark>=5.2.3",
   "pytest-cov>=7.0.0",
-  "ruff>=0.14.8",
-  "ty>=0.0.8",
+  "ruff>=0.15.6",
 ]
 
 [tool.pytest.ini_options]
@@ -49,9 +49,11 @@ testpaths = ["tests"]
 
 [tool.poe.tasks]
 # Code quality
-lint = "ruff check"
-fmt = "ruff format"
-tc = "ty check"
+ruff = "uv run ruff"
+mypy = "uv run mypy"
+lint = "poe ruff check"
+fmt = "poe ruff format"
+tc = "poe mypy ."
 
 # Testing
 test = "pytest"

{python_neva-2.1.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.1.0 → python_neva-2.2.1}/tests/testing/test_refresh_database.py

@@ -83,3 +83,29 @@ class TestRefreshDatabaseMechanism(DatabaseTestCase):
 
         result = await session.execute(select(Item).where(Item.id == 10))
         assert result.scalar_one().name == "Visible"
+
+
+class TestRefreshDatabaseNestedRollback(DatabaseTestCase):
+    """Verify that data written inside a nested db.begin() is rolled back.
+
+    A nested begin() releases a savepoint on exit, folding its writes into
+    the outer connection-level transaction. The outer RefreshDatabase rollback
+    must undo those writes too. Tests use an a/b prefix to enforce order.
+    """
+
+    async def test_a_write_inside_nested_begin(self) -> None:
+        """Write via a nested db.begin() that exits normally (savepoint released)."""
+        db = self.app.make(DatabaseManager).unwrap()
+        async with db.begin() as tx:
+            tx.session.add(Item(id=50, name="Nested"))
+            await tx.session.flush()
+
+            result = await tx.session.execute(select(Item).where(Item.id == 50))
+            assert result.scalar_one().name == "Nested"
+
+    async def test_b_nested_write_is_gone_after_rollback(self) -> None:
+        """The savepoint-released write must not survive across tests."""
+        db = self.app.make(DatabaseManager).unwrap()
+        async with db.begin() as tx:
+            result = await tx.session.execute(select(Item).where(Item.id == 50))
+            assert result.scalar_one_or_none() is None