python-neva 3.4.0__tar.gz → 3.5.1__tar.gz

python_neva-3.5.1/.claude/settings.local.json

@@ -0,0 +1,18 @@
+{
+  "permissions": {
+    "allow": [
+      "Read(//home/m.bigaignon/.claude/**)",
+      "Read(//home/m.bigaignon/projects/neva/**)",
+      "Bash(git -C /home/m.bigaignon/projects/neva/neva tag)",
+      "Bash(git *)",
+      "Bash(python -c \"import dishka; print\\(dishka.__version__ if hasattr\\(dishka,'__version__'\\) else 'n/a'\\); print\\([n for n in dir\\(dishka\\) if not n.startswith\\('_'\\)]\\)\")",
+      "Bash(.venv/bin/python -c \"import dishka; print\\([n for n in dir\\(dishka\\) if not n.startswith\\('_'\\)]\\)\")",
+      "Bash(python .github/scripts/validate-skill-frontmatter.py)",
+      "Bash(npx --yes markdownlint-cli2 \"python/skills/**/*.md\")",
+      "Read(//home/m.bigaignon/projects/xefi/claude-skills/**)",
+      "Bash(python -)",
+      "Bash(npx --yes markdownlint-cli2 \"python/**/*.md\")",
+      "Bash(BASE_REF=origin/main python .github/scripts/check-version-bump.py)"
+    ]
+  }
+}

{python_neva-3.4.0 → python_neva-3.5.1}/.gitignore

@@ -18,4 +18,3 @@ profiles/
 
 # LLM Contexts
 llm-context.md
-CLAUDE.md

python_neva-3.5.1/CHANGELOG.md

@@ -0,0 +1,48 @@
+## 3.5.1 (2026-08-24)
+
+### 🐛🚑️ Fixes
+
+- **database**: run commit callbacks after the commit, not before
+
+### 📝💡 Documentation
+
+- **general**: update docs
+- **README**: very short section on contribution
+- **docs**: extension ideas
+
+## 3.5.0 (2026-06-11)
+
+### ✨ Features
+
+- **arch**: improve app facade stub
+- **events**: make the event facade properly depend on the dispatcher contract
+- **events**: new tests for events
+
+### 🐛🚑️ Fixes
+
+- **events**: fixing handling of async before-dispatch hooks
+
+### 🏷️ Types
+
+- **events**: improve event facade stub
+
+## 3.4.0 (2026-06-10)
+
+### ✨ Features
+
+- **arch**: new from_context method
+- **tooling**: placeholder commit
+
+### 💚👷 CI & Build
+
+- **tooling**: default to base tag version for commitizen
+
+### 📝💡 Documentation
+
+- **project**: update doc
+- **core**: placeholde readme
+
+### 🔧🔨📦️ Configuration, Scripts, Packages
+
+- **tooling**: update changelog script
+- **project**: update versioning config

python_neva-3.5.1/CLAUDE.md

@@ -0,0 +1,138 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+`python-neva` is the **core** of the Neva framework — a Laravel-inspired toolkit
+for Python. It provides dependency injection (dishka), service providers,
+facades, Result/Option types for error handling, security features, a
+transaction-aware event system, and a SQLAlchemy-based database layer.
+
+**Critical rule — the core MUST stay framework-agnostic.** No web/HTTP types,
+no messaging concerns in this package. FastAPI-specific code belongs in
+`neva-fastapi`, FastStream in `neva-faststream`, auth in `neva-auth`. If you
+find yourself reaching for `fastapi.*` (or any framework binding) inside
+`neva/`, that's a smell — it belongs in an integration package. The plugin
+ecosystem is listed in `README.md`.
+
+**Python Version:** 3.12+
+**Build System:** uv + hatchling
+**Type checker:** mypy (with the `pydantic.mypy` plugin and the `TypeForm` incomplete feature)
+
+## Commands
+
+```bash
+# Development (poe task aliases)
+poe lint              # ruff check
+poe fmt               # ruff format
+poe tc                # mypy .
+poe test              # pytest
+poe test-cov          # tests with coverage (--cov-report=term-missing)
+poe test-full         # coverage over the neva package
+
+# Run a single test
+pytest tests/test_file.py::TestClass::test_method -v
+```
+
+`asyncio_mode = "auto"` — async tests need no `@pytest.mark.asyncio`.
+
+## Architecture
+
+```
+neva/
+├── arch/           # Core: DI container, application, facades, service providers, scopes
+├── config/         # Configuration system (repository, loader, providers)
+├── database/       # Database layer (SQLAlchemy async, transactions, manager)
+├── events/         # Transaction-aware event system with dispatch policies
+├── security/       # Hashing (argon2/bcrypt), encryption (AES-GCM), tokens
+├── obs/            # Observability: structured logging (structlog), profiling
+├── polyfactory/    # Factory helpers built on Polyfactory
+├── support/        # Utilities: Result/Option types, facades, time/string helpers
+└── testing/        # TestCase base, RefreshDatabase, fixtures
+```
+
+## Key Patterns
+
+**Error Handling** - Always return `Result[T, str]` or `Option[T]` for fallible operations:
+```python
+def resolve(self, interface: type[T]) -> Result[T, str]:
+    try:
+        return Ok(self.container.get(interface))
+    except Exception as e:
+        return Err(f"Failed: {e}")
+```
+
+**Facades** - Static interfaces to services:
+```python
+from neva.support.facade import DB, Hash, Config, Crypt, Log, Event
+
+hashed = Hash.make("password")
+config = Config.get("app.name").unwrap_or("MyApp")
+await Event.dispatch(UserCreated(event_id=1, user_id=42))
+```
+
+**Service Providers** - Register services with lifecycle hooks:
+```python
+class MyProvider(ServiceProvider):
+    def register(self) -> Result[Self, str]:
+        self.bind(MyService)
+        return Ok(self)
+
+    @asynccontextmanager
+    async def lifespan(self) -> AsyncIterator[None]:
+        yield  # startup/shutdown
+```
+
+**Events** - Transaction-aware dispatch with IMMEDIATE and DEFERRED policies:
+```python
+# Events are generic Pydantic models with an event_id and auto-timestamp
+class UserCreated(Event[int]):
+    user_id: int
+
+# Class-based listener (default policy: IMMEDIATE)
+class SendWelcomeEmail(EventListener[UserCreated]):
+    policy = HandlingPolicy.DEFERRED
+
+    async def handle(self, event: UserCreated) -> Result[None, str]:
+        await mailer.send(event.user_id)
+        return Ok(None)
+
+# Function-based listener via decorator
+@listener(policy=HandlingPolicy.DEFERRED)
+async def log_user_created(event: UserCreated) -> Result[None, str]:
+    log.info("user created", user_id=event.user_id)
+    return Ok(None)
+```
+
+DEFERRED listeners execute after the enclosing transaction commits; outside a transaction they fire immediately. Listeners are resolved from the DI container with fallback to direct instantiation.
+
+**Testing** - Async by default with TestCase base:
+```python
+class TestMyService(TestCase):
+    async def test_something(self):
+        service = self.app.make(MyService).unwrap()
+        result = await service.do_something()
+        assert result.is_ok
+```
+
+For database tests, subclass `RefreshDatabase` (wraps each test in a transaction and rolls it back).
+
+## Code Conventions
+
+- **Type hints required** - Full annotations, uses Python 3.12+ features
+- **Google-style docstrings** - Enforced by ruff DOC/D rules
+- **Async first** - All I/O operations are async/await
+- **Naming**: Events past tense (UserCreated), Class listeners imperative (SendWelcomeEmail), Function listeners snake_case handlers (log_user_created), Services noun phrases (EmailService)
+- **Ruff rules** (config in a separate `ruff.toml`, `preview = true`): FAST, ANN, ASYNC, S, FBT, B, A, C4, DTZ, ISC, ICN, SIM, SLOT, I, E, W, DOC, D, F, RUF
+
+## Commits & releases
+
+Conventional Commits with gitmoji via `cz_gitmoji` (`cz commit`). Releases are
+cut with `cz bump`, which writes `CHANGELOG.md` and runs
+`scripts/retag-with-changelog.sh` to annotate the new `v<version>` tag with the
+rendered changelog. See `README.md` for the full flow and the plugin list.
+
+## Documentation
+
+- Architecture guides: `wiki/architecture/`

python_neva-3.5.1/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.5
+Name: python-neva
+Version: 3.5.1
+Summary: Add your description here
+Requires-Python: >=3.12
+Requires-Dist: aiosqlite>=0.20.0
+Requires-Dist: asyncpg>=0.30.0
+Requires-Dist: cryptography>=46.0.3
+Requires-Dist: dishka>=1.10.0
+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
+Requires-Dist: structlog>=25.5.0
+Requires-Dist: typer>=0.21.1
+Provides-Extra: fastapi
+Requires-Dist: neva-fastapi>=1.0.0; extra == 'fastapi'
+Provides-Extra: testing
+Requires-Dist: pytest-asyncio>=0.25.3; extra == 'testing'
+Requires-Dist: pytest>=9.0.2; extra == 'testing'
+Description-Content-Type: text/markdown
+
+# python-neva
+
+The core of the **Neva** framework — a Laravel-inspired toolkit for Python that
+brings Laravel's philosophy, terminology, and conventions to the Python
+ecosystem: service providers, facades, `bind`/`make` dependency injection (on
+[dishka](https://github.com/reagento/dishka)), `Hash`/`Crypt`/`Config`/`Log`/`Event`
+facades, a transaction-aware event system, and Result/Option error handling.
+
+`python-neva` is the **framework-agnostic core**. Web- and protocol-specific
+concerns live in separate integration packages (the plugins below) so the core
+never depends on a particular HTTP or messaging framework.
+
+## Plugins & ecosystem
+
+Neva is split into one repository per package. The core is published as
+[`python-neva`](https://pypi.org/project/python-neva/); each plugin is an
+independent repo, independently versioned and published.
+
+| Package           | Repo / directory   | Role                                                                                  | Status                          |
+| ----------------- | ------------------ | ------------------------------------------------------------------------------------- | ------------------------------- |
+| `python-neva`     | `neva/`            | **Core, framework-agnostic.** DI, service providers, facades, Result/Option, events, security, observability, SQLAlchemy database layer. | published ([PyPI](https://pypi.org/project/python-neva/)) |
+| `neva-fastapi`    | `neva-fastapi/`    | FastAPI integration — `App` extends `FastAPI` and wires dishka into routes. Pulled in via the `python-neva[fastapi]` extra. | published ([PyPI](https://pypi.org/project/neva-fastapi/)) |
+| `neva-faststream` | `neva-faststream/` | FastStream (messaging) integration.                                                   | scaffolded, early placeholder   |
+| `neva-auth`       | `neva-auth/`       | Authentication & identity toolkit — token-issuance engine, OAuth2 grants, guards, pluggable formats/backends. | core complete, OAuth-server slice in progress |
+| `neva-example`    | `neva-example/`    | Reference application consuming `python-neva[fastapi]`. Not published; demonstration + integration test bed. | unpublished                     |
+
+> When working across packages locally, each repo can be cloned as a sibling
+> directory; integration packages depend on `python-neva` from PyPI (or an
+> editable local path during development).
+
+## Develop
+
+```bash
+uv sync          # install/refresh deps from uv.lock
+poe lint         # ruff check
+poe fmt          # ruff format
+poe tc           # type-check (mypy)
+poe test         # pytest
+poe test-cov     # tests with coverage
+
+# Run a single test
+pytest tests/test_file.py::TestClass::test_method -v
+```
+
+`asyncio_mode = "auto"` is set, so async tests need no `@pytest.mark.asyncio`.
+
+## Contributing
+
+**Commits** follow [Conventional Commits](https://www.conventionalcommits.org/)
+with [gitmoji](https://gitmoji.dev/) prefixes, enforced by
+[`cz_gitmoji`](https://github.com/ljnsn/cz-conventional-gitmoji). Commitizen is
+provided as a dev dependency — no separate install needed. Run the guided
+wizard:
+
+```bash
+cz commit
+```
+
+or format manually as `:gitmoji: type(scope): subject`.
+
+**Releases** are cut per-repo with commitizen, from the repo root:
+
+```bash
+cz bump                              # bump version in pyproject, write CHANGELOG, tag v<version>
+git push --follow-tags origin main
+uv build && uv publish               # build + publish the wheel/sdist
+```
+
+`cz bump` derives the bump level (major/minor/patch) from the commits since the
+last tag, updates `CHANGELOG.md`, and runs `scripts/retag-with-changelog.sh` to
+rewrite the new tag with the rendered changelog as its annotation.
+
+## Feature ideas
+
+- Feature-parity FastStream integration (now scaffolded as `neva-faststream`)
+- Finish cleaning up the core package (moving any remaining ASGI-dependent code into the appropriate integration packages)
+- Improved router registration (auto-discovery OR provider-based? both?)
+- Improved security tooling (performance improvements, better defaults, etc.)
+- Better OpenTelemetry integration
+- Improved factory module (based on Polyfactory)
+- Queue/Jobs system
+- CLI integration

python_neva-3.5.1/README.md

@@ -0,0 +1,82 @@
+# python-neva
+
+The core of the **Neva** framework — a Laravel-inspired toolkit for Python that
+brings Laravel's philosophy, terminology, and conventions to the Python
+ecosystem: service providers, facades, `bind`/`make` dependency injection (on
+[dishka](https://github.com/reagento/dishka)), `Hash`/`Crypt`/`Config`/`Log`/`Event`
+facades, a transaction-aware event system, and Result/Option error handling.
+
+`python-neva` is the **framework-agnostic core**. Web- and protocol-specific
+concerns live in separate integration packages (the plugins below) so the core
+never depends on a particular HTTP or messaging framework.
+
+## Plugins & ecosystem
+
+Neva is split into one repository per package. The core is published as
+[`python-neva`](https://pypi.org/project/python-neva/); each plugin is an
+independent repo, independently versioned and published.
+
+| Package           | Repo / directory   | Role                                                                                  | Status                          |
+| ----------------- | ------------------ | ------------------------------------------------------------------------------------- | ------------------------------- |
+| `python-neva`     | `neva/`            | **Core, framework-agnostic.** DI, service providers, facades, Result/Option, events, security, observability, SQLAlchemy database layer. | published ([PyPI](https://pypi.org/project/python-neva/)) |
+| `neva-fastapi`    | `neva-fastapi/`    | FastAPI integration — `App` extends `FastAPI` and wires dishka into routes. Pulled in via the `python-neva[fastapi]` extra. | published ([PyPI](https://pypi.org/project/neva-fastapi/)) |
+| `neva-faststream` | `neva-faststream/` | FastStream (messaging) integration.                                                   | scaffolded, early placeholder   |
+| `neva-auth`       | `neva-auth/`       | Authentication & identity toolkit — token-issuance engine, OAuth2 grants, guards, pluggable formats/backends. | core complete, OAuth-server slice in progress |
+| `neva-example`    | `neva-example/`    | Reference application consuming `python-neva[fastapi]`. Not published; demonstration + integration test bed. | unpublished                     |
+
+> When working across packages locally, each repo can be cloned as a sibling
+> directory; integration packages depend on `python-neva` from PyPI (or an
+> editable local path during development).
+
+## Develop
+
+```bash
+uv sync          # install/refresh deps from uv.lock
+poe lint         # ruff check
+poe fmt          # ruff format
+poe tc           # type-check (mypy)
+poe test         # pytest
+poe test-cov     # tests with coverage
+
+# Run a single test
+pytest tests/test_file.py::TestClass::test_method -v
+```
+
+`asyncio_mode = "auto"` is set, so async tests need no `@pytest.mark.asyncio`.
+
+## Contributing
+
+**Commits** follow [Conventional Commits](https://www.conventionalcommits.org/)
+with [gitmoji](https://gitmoji.dev/) prefixes, enforced by
+[`cz_gitmoji`](https://github.com/ljnsn/cz-conventional-gitmoji). Commitizen is
+provided as a dev dependency — no separate install needed. Run the guided
+wizard:
+
+```bash
+cz commit
+```
+
+or format manually as `:gitmoji: type(scope): subject`.
+
+**Releases** are cut per-repo with commitizen, from the repo root:
+
+```bash
+cz bump                              # bump version in pyproject, write CHANGELOG, tag v<version>
+git push --follow-tags origin main
+uv build && uv publish               # build + publish the wheel/sdist
+```
+
+`cz bump` derives the bump level (major/minor/patch) from the commits since the
+last tag, updates `CHANGELOG.md`, and runs `scripts/retag-with-changelog.sh` to
+rewrite the new tag with the rendered changelog as its annotation.
+
+## Feature ideas
+
+- Feature-parity FastStream integration (now scaffolded as `neva-faststream`)
+- Finish cleaning up the core package (moving any remaining ASGI-dependent code into the appropriate integration packages)
+- Improved router registration (auto-discovery OR provider-based? both?)
+- Improved security tooling (performance improvements, better defaults, etc.)
+- Better OpenTelemetry integration
+- Improved factory module (based on Polyfactory)
+- Queue/Jobs system
+- CLI integration

{python_neva-3.4.0 → python_neva-3.5.1}/neva/database/connection.py

@@ -95,7 +95,7 @@ class ConnectionManager:
 
     @asynccontextmanager
     async def _scoped(self, tx: BoundTransaction) -> AsyncIterator[None]:
-        """Manage registry, state transitions, and callbacks for a transaction.
+        """Expose the transaction on the registry for the duration of the block.
 
         Yields:
             None
@@ -108,40 +108,37 @@ class ConnectionManager:
         )
         try:
             yield
-            if tx.rollback_requested:
-                tx.state = TransactionState.ROLLED_BACK
-                if tx.is_root:
-                    for result in await tx.execute_on_rollback_callbacks():
-                        if result.is_err and self.logger is not None:
-                            self.logger.error(
-                                "rollback callback failed",
-                                error=result.err().unwrap(),
-                                connection=self.name,
-                            )
-            else:
-                tx.state = TransactionState.COMMITTED
-                if tx.is_root:
-                    for result in await tx.execute_on_commit_callbacks():
-                        if result.is_err and self.logger is not None:
-                            self.logger.error(
-                                "commit callback failed",
-                                error=result.err().unwrap(),
-                                connection=self.name,
-                            )
-        except BaseException:
-            tx.state = TransactionState.ROLLED_BACK
-            if tx.is_root:
-                for result in await tx.execute_on_rollback_callbacks():
-                    if result.is_err and self.logger is not None:
-                        self.logger.error(
-                            "rollback callback failed",
-                            error=result.err().unwrap(),
-                            connection=self.name,
-                        )
-            raise
         finally:
             _tx_registry.reset(token)
 
+    async def _settle(self, tx: BoundTransaction, *, committed: bool) -> None:
+        """Mark the transaction settled and drain its callbacks.
+
+        Callers must have already committed or rolled back the underlying
+        session: callbacks observe a settled transaction, and the registry no
+        longer exposes it, so a callback touching the database opens its own
+        transaction rather than reusing the drained one.
+        """
+        tx.state = (
+            TransactionState.COMMITTED if committed else TransactionState.ROLLED_BACK
+        )
+        if not tx.is_root:
+            return
+
+        results = (
+            await tx.execute_on_commit_callbacks()
+            if committed
+            else await tx.execute_on_rollback_callbacks()
+        )
+        label = "commit" if committed else "rollback"
+        for result in results:
+            if result.is_err and self.logger is not None:
+                self.logger.error(
+                    f"{label} callback failed",
+                    error=result.err().unwrap(),
+                    connection=self.name,
+                )
+
     @asynccontextmanager
     async def begin(self) -> AsyncIterator[BoundTransaction]:
         """Open a new bound transaction with an active database session.
@@ -162,23 +159,27 @@ class ConnectionManager:
                 try:
                     async with self._scoped(tx):
                         yield tx
-                    if tx.rollback_requested:
-                        await sp.rollback()
-                    else:
-                        await sp.commit()
+                        if tx.rollback_requested:
+                            await sp.rollback()
+                        else:
+                            await sp.commit()
                 except BaseException:
                     await sp.rollback()
+                    await self._settle(tx, committed=False)
                     raise
+                await self._settle(tx, committed=not tx.rollback_requested)
             case _:
                 async with self.session_factory() as session:
                     tx = BoundTransaction(self.name, session)
                     try:
                         async with self._scoped(tx):
                             yield tx
-                        if tx.rollback_requested:
-                            await session.rollback()
-                        else:
-                            await session.commit()
+                            if tx.rollback_requested:
+                                await session.rollback()
+                            else:
+                                await session.commit()
                     except BaseException:
                         await session.rollback()
+                        await self._settle(tx, committed=False)
                         raise
+                    await self._settle(tx, committed=not tx.rollback_requested)

{python_neva-3.4.0 → python_neva-3.5.1}/neva/events/dispatcher.py

@@ -1,5 +1,6 @@
 """Base implementation of the event dispatcher."""
 
+import inspect
 from typing import override
 
 from neva.arch.application import Application
@@ -35,11 +36,9 @@ class EventDispatcher(contracts.EventDispatcher):
             event: The event about to be dispatched.
         """
         for hook in self._before_dispatch_hooks:
-            match hook:
-                case contracts.AsyncBeforeDispatchHook():
-                    await hook(event)
-                case contracts.SyncBeforeDispatchHook():
-                    hook(event)
+            result = hook(event)
+            if inspect.isawaitable(result):
+                await result
 
     @override
     async def before_dispatch(self, hook: contracts.BeforeDispatchHook) -> None:

python_neva-3.5.1/neva/support/facade/app.pyi

@@ -0,0 +1,47 @@
+"""Type stub for App facade."""
+
+from contextlib import AbstractAsyncContextManager
+from typing import Any, Self, override
+
+from neva.arch import Facade
+from neva.arch.scopes import BaseScope
+from neva.support import Result
+
+class App(Facade):
+    @classmethod
+    @override
+    def get_facade_accessor(cls) -> type: ...
+    @classmethod
+    async def make_async[T](cls, interface: type[T]) -> Result[T, str]:
+        """Resolve and instanciate a type from the container.
+
+        Returns:
+            Result containing the resolved type instance or an error message.
+        """
+
+    @classmethod
+    def make[T](cls, interface: type[T]) -> Result[T, str]:
+        """Resolve an interface from the container by its alias.
+
+        Attempts to retrieve and instantiate an object from the dependency
+        injection container.
+
+        Args:
+            interface: The interface to resolve.
+
+        Returns:
+            Result containing the resolved service instance or an error message.
+
+        """
+
+    @classmethod
+    async def scope(
+        cls,
+        scope: BaseScope | None = None,
+        context: dict[type, Any] | None = None,
+    ) -> AbstractAsyncContextManager[Self]:
+        """Enter a new scope.
+
+        Yields:
+            The application instance with the new scope.
+        """

{python_neva-3.4.0 → python_neva-3.5.1}/neva/support/facade/event.py

@@ -5,7 +5,7 @@ from contextlib import contextmanager
 from typing import TYPE_CHECKING, override
 
 from neva.arch import Facade
-from neva.events import EventDispatcher
+from neva.events import contracts
 
 
 if TYPE_CHECKING:
@@ -23,7 +23,7 @@ class Event(Facade):
         Returns:
             EventDispatcher class.
         """
-        return EventDispatcher
+        return contracts.EventDispatcher
 
     @classmethod
     def fake(cls) -> "EventFake":

{python_neva-3.4.0 → python_neva-3.5.1}/neva/support/facade/event.pyi

@@ -13,10 +13,15 @@ class Event(Facade):
     @override
     def get_facade_accessor(cls) -> type: ...
     @classmethod
-    async def dispatch(cls, event: contracts.Event) -> list[Result[None, str]]: ...
+    async def before_dispatch(cls, hook: contracts.BeforeDispatchHook) -> None:
+        """Register a hook to be called before listeners are invoked."""
+    @classmethod
+    async def dispatch(cls, event: contracts.Event) -> list[Result[None, str]]:
+        """Dispatch an event to all registered listeners."""
     @classmethod
     def listen[T: contracts.Event](
         cls,
         event_cls: type[T],
         listener_cls: type[contracts.EventListener[T]],
-    ) -> None: ...
+    ) -> None:
+        """Register a listener for an event."""

{python_neva-3.4.0 → python_neva-3.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-neva"
-version = "3.4.0"
+version = "3.5.1"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"

{python_neva-3.4.0 → python_neva-3.5.1}/tests/database/test_sqlalchemy_integration.py

@@ -118,6 +118,40 @@ class TestOnCommitCallbacks:
 
         assert results == ["committed"]
 
+    async def test_on_commit_runs_after_the_root_commit(
+        self, db: DatabaseManager
+    ) -> None:
+        observed: dict[str, bool] = {}
+
+        async with db.begin() as tx:
+            tx.session.add(User(id=21, name="Committed"))
+
+            async def on_commit() -> Result[None, str]:
+                observed["in_transaction"] = tx.session.in_transaction()
+                return Ok(None)
+
+            _ = tx.on_commit(on_commit)
+
+        assert observed["in_transaction"] is False
+
+    async def test_on_commit_callback_writes_in_its_own_transaction(
+        self, db: DatabaseManager
+    ) -> None:
+        async with db.begin() as tx:
+            tx.session.add(User(id=23, name="Trigger"))
+
+            async def on_commit() -> Result[None, str]:
+                assert db.current().is_nothing
+                async with db.begin() as own:
+                    own.session.add(User(id=24, name="FromCallback"))
+                return Ok(None)
+
+            _ = tx.on_commit(on_commit)
+
+        async with db.begin() as tx:
+            row = await tx.session.execute(select(User).where(User.id == 24))
+            assert row.scalar_one().name == "FromCallback"
+
     async def test_on_rollback_fires_on_error(self, db: DatabaseManager) -> None:
         results: list[str] = []