python-neva 3.5.0__tar.gz → 3.6.0__tar.gz

python_neva-3.6.0/.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.5.0 → python_neva-3.6.0}/.gitignore

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

python_neva-3.6.0/.pre-commit-config.yaml

@@ -0,0 +1,33 @@
+repos:
+  - repo: https://github.com/gitleaks/gitleaks
+    rev: v8.30.1
+    hooks:
+      - id: gitleaks
+
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+      - id: check-case-conflict
+      - id: check-merge-conflict
+      - id: debug-statements
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.6
+    hooks:
+      - id: ruff
+        args: [--fix, --exit-non-zero-on-fix]
+      - id: ruff-format
+
+  - repo: local
+    hooks:
+      - id: pyrefly
+        name: Pyrefly (type checking)
+        entry: uv run pyrefly check
+        language: system
+        types_or: [python, pyi]
+        pass_filenames: false
+        require_serial: true

python_neva-3.6.0/CHANGELOG.md

@@ -0,0 +1,74 @@
+## 3.6.0 (2026-08-28)
+
+### ✨ Features
+
+- **arch**: name the binding lifetimes, deprecate the implicit one
+- **security**: add make_async and check_async
+- **arch**: expose the container backing the current scope
+
+### 🐛🚑️ Fixes
+
+- **events**: dispatch once per registration, and defer to the outermost transaction
+- **config**: make freeze() actually freeze and merge() recursive
+- **config**: stop config files from displacing real modules
+- **arch**: run lifespan teardown even when the body raises
+- **security**: stop requiring the optional hasher tuning config
+- **arch**: make register() bind, or say why it cannot
+- **database**: keep the transaction when the registry contextvar is unset
+
+### 📝💡 Documentation
+
+- **general**: correct the Config stub, a lying docstring and a wrong annotation
+
+### 🔧🔨📦️ Configuration, Scripts, Packages
+
+- **tooling**: replace mypy with pyrefly at strict
+
+## 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.6.0/CLAUDE.md

@@ -0,0 +1,141 @@
+# 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:** pyrefly (`preset = "strict"`, configured in `[tool.pyrefly]`)
+
+## Commands
+
+```bash
+# Development (poe task aliases)
+poe lint              # ruff check
+poe fmt               # ruff format
+poe tc                # pyrefly check
+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. Bindings
+declare a lifetime by name — `singleton` (one per process), `scoped` (one per
+REQUEST scope), `transient` (one per resolution), `instance` (an object you
+already have). Bare `bind` without an explicit `scope`/`cache` is deprecated:
+```python
+class MyProvider(ServiceProvider):
+    def register(self) -> Result[Self, str]:
+        _ = self.singleton(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.6.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.5
+Name: python-neva
+Version: 3.6.0
+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 (pyrefly)
+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.6.0/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 (pyrefly)
+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.0 → python_neva-3.6.0}/neva/arch/application.py

@@ -43,6 +43,9 @@ class Application:
         self.config: ConfigRepository = ConfigRepository()
         self.providers: OrderedDict[type, ServiceProvider] = OrderedDict()
         self.root_provider: dishka.Provider = dishka.Provider(scope=Scope.APP)
+        self._extra_providers: list[BaseProvider] = []
+        self._container: dishka.AsyncContainer | None = None
+        self._booted: bool = False
 
         configuration_path = (
             config_path
@@ -77,30 +80,70 @@ class Application:
         _ = self.root_provider.provide(source=lambda: self, provides=Application)
         self.register_providers(providers)
         self._bind_event_listeners()
-        self.build_container(self.root_provider)
+        self.build_container()
 
-    def build_container(self, *providers: BaseProvider) -> None:
-        """Build the application container."""
-        self.container: dishka.AsyncContainer = dishka.make_async_container(
+    @property
+    def container(self) -> dishka.AsyncContainer:
+        """The application container, built on first access.
+
+        Registering a provider discards the built container so the next access
+        rebuilds the graph with that provider's bindings in it.
+
+        Returns:
+            The application container.
+        """
+        if self._container is not None:
+            return self._container
+        return self.build_container()
+
+    def build_container(self, *providers: BaseProvider) -> dishka.AsyncContainer:
+        """Build the application container.
+
+        Args:
+            providers: Extra dishka providers to compose into the graph. They
+                are remembered, so a later rebuild keeps them.
+
+        Returns:
+            The freshly built container.
+        """
+        self._extra_providers.extend(providers)
+        self._container = dishka.make_async_container(
             self.root_provider,
             *[p.provider for p in self.providers.values()],
-            *providers,
+            *self._extra_providers,
         )
+        return self._container
 
     def register(self, provider: type[ServiceProvider]) -> Result[ServiceProvider, str]:
         """Registers a service provider with the application.
 
+        Providers must be registered before the application boots: dishka
+        validates the dependency graph when the container is built, and the
+        booted container already holds APP-scoped instances that a rebuild
+        would orphan. Registering after boot is an error rather than a
+        silently ignored call.
+
         Returns:
             Result containing the registered provider instance or an error message.
         """
         if provider in self.providers:
             return Ok(self.providers[provider])
 
-        return (
+        if self._booted:
+            return Err(
+                f"Cannot register '{provider.__name__}': the application is "
+                "already booted. Register providers before entering lifespan(), "
+                "or declare them in the 'providers' config namespace."
+            )
+
+        registered = (
             provider(self)
             .register()
             .map(lambda p: self.providers.setdefault(provider, p))
         )
+        if registered.is_ok:
+            self._container = None
+        return registered
 
     def register_providers(self, providers: Sequence[type[ServiceProvider]]) -> None:
         """Registers a set of providers."""
@@ -122,15 +165,28 @@ class Application:
             provides=interface,
         )
 
+    @property
+    def current_container(self) -> dishka.AsyncContainer:
+        """The container backing resolution in the current context.
+
+        Inside ``scope()`` this is the child container for that scope; outside
+        it, the application container. Integrations that hand a container to
+        another framework — a request-scoped container to a route layer, say —
+        want this one, not ``container``.
+
+        Returns:
+            The innermost container entered in this context.
+        """
+        return _current_container.get(self.container)
+
     async def make_async[T](self, 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.
         """
-        container = _current_container.get(self.container)
         try:
-            return Ok(await container.get(interface))
+            return Ok(await self.current_container.get(interface))
         except Exception as e:
             return Err(f"Failed to resolve service '{interface.__name__}': {e}")
 
@@ -140,7 +196,7 @@ class Application:
         Returns:
             Result containing the resolved type instance or an error message.
         """
-        container = _current_container.get(self.container)
+        container = self.current_container
         try:
             return Ok(container.get_sync(interface))
         except Exception as e:
@@ -154,11 +210,13 @@ class Application:
     ) -> AsyncGenerator[Self]:
         """Enter a new scope.
 
+        The application is yielded, not the child container; read
+        ``current_container`` inside the block to reach it.
+
         Yields:
             The application instance with the new scope.
         """
-        parent = _current_container.get(self.container)
-        async with parent(scope=scope, context=context) as container:
+        async with self.current_container(scope=scope, context=context) as container:
             token = _current_container.set(container)
             try:
                 yield self
@@ -169,24 +227,32 @@ class Application:
     async def lifespan(self) -> AsyncGenerator[None]:
         """Wire the facades and providers."""
         Facade.set_facade_application(self)
+        self._booted = True
 
-        async with AsyncExitStack() as stack:
-            for provider in self.providers.values():
-                if isinstance(provider, Bootable):
-                    await stack.enter_async_context(provider.lifespan())
-
-            await self._wire_event_listeners()
-            yield
-
-        await self.container.close()
-        Facade.reset_facade_application()
+        try:
+            async with AsyncExitStack() as stack:
+                for provider in self.providers.values():
+                    if isinstance(provider, Bootable):
+                        await stack.enter_async_context(provider.lifespan())
+
+                await self._wire_event_listeners()
+                yield
+        finally:
+            # Read `_container` rather than the property: the container may
+            # never have been built, and closing is no reason to build one.
+            if self._container is not None:
+                await self._container.close()
+            self._booted = False
+            Facade.reset_facade_application()
 
     def _bind_event_listeners(self) -> None:
         """Bind all listener classes declared in provider ``listen`` dicts."""
         for provider in self.providers.values():
             for listeners in provider.listen.values():
                 for listener_cls in listeners:
-                    self.bind(listener_cls)
+                    # Straight onto the root provider: routing this through the
+                    # deprecated `bind` warned on every boot.
+                    _ = self.root_provider.provide(listener_cls, scope=Scope.APP)
 
     async def _wire_event_listeners(self) -> None:
         """Wire event-listener mappings from all providers onto the dispatcher."""

{python_neva-3.5.0 → python_neva-3.6.0}/neva/arch/config.py

@@ -24,7 +24,7 @@ class AppConfig(TypedDict):
     openapi_url: NotRequired[str]
     docs_url: NotRequired[str]
     redoc_url: NotRequired[str]
-    providers: NotRequired[list[ServiceProvider]]
+    providers: NotRequired[list[type[ServiceProvider]]]
 
 
 class ProviderConfig(TypedDict):
@@ -34,4 +34,4 @@ class ProviderConfig(TypedDict):
         providers: List of service providers to register.
     """
 
-    providers: NotRequired[list[ServiceProvider]]
+    providers: NotRequired[list[type[ServiceProvider]]]

{python_neva-3.5.0 → python_neva-3.6.0}/neva/arch/scopes.py

@@ -2,4 +2,3 @@ from dishka.entities.scope import BaseScope, Scope
 
 
 __all__ = ["BaseScope", "Scope"]
-