python-neva 3.5.0__py3-none-any.whl → 3.6.0__py3-none-any.whl

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."""

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]]]

neva/arch/scopes.py

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

neva/arch/service_provider.py

@@ -8,6 +8,7 @@ container and optionally managing their lifecycle.
 from __future__ import annotations
 
 import abc
+import warnings
 from contextlib import AbstractAsyncContextManager
 from typing import (
     TYPE_CHECKING,
@@ -70,7 +71,7 @@ class ServiceProvider(abc.ABC):
     """
 
     app: "Application"
-    listen: ClassVar[dict[type[Event], list[type[EventListener[Any]]]]] = {}
+    listen: ClassVar[dict[type[Event[Any]], list[type[EventListener[Any]]]]] = {}
     when: ClassVar[Marker | None] = None
 
     def __init__(self, app: "Application") -> None:
@@ -106,17 +107,91 @@ class ServiceProvider(abc.ABC):
         interface: type | None = None,
         scope: BaseScope | None = None,
         when: BaseMarker | None = None,
-        cache: bool = True,
+        cache: bool | None = None,
     ) -> None:
-        """Binds a source to the container."""
+        """Binds a source to the container.
+
+        Prefer the named lifetimes — `singleton`, `scoped`, `transient`,
+        `instance` — which say what they mean. Use `bind` directly only to
+        reach a scope those do not cover, and then pass `scope` explicitly.
+
+        Calling this with neither `scope` nor `cache` is deprecated: the
+        resulting binding is a process-wide singleton, which is the opposite of
+        Laravel's transient `bind`, and nothing at the call site says so.
+
+        Args:
+            source: The class or factory to bind.
+            interface: The type to resolve it as. Defaults to `source`.
+            scope: The dishka scope. Defaults to the provider's (APP).
+            when: Marker gating this binding.
+            cache: Whether to reuse one instance per scope. Defaults to True.
+        """
+        if scope is None and cache is None:
+            warnings.warn(
+                "bind() without an explicit lifetime is deprecated and will "
+                "require one in 4.0. It currently creates a process-wide "
+                "singleton: use singleton() for that, or scoped() / "
+                "transient() / instance(), or pass scope= or cache= yourself.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
         _ = self.provider.provide(
             source=source,
             scope=scope,
             provides=interface,
-            cache=cache,
+            cache=True if cache is None else cache,
             when=when,
         )
 
+    def singleton(
+        self,
+        source: type | Callable[..., Any],
+        *,
+        interface: type | None = None,
+        when: BaseMarker | None = None,
+    ) -> Self:
+        """Binds the source at APP scope, as one instance for the process.
+
+        This is what a bare `bind` has always done; naming it makes the
+        lifetime visible at the call site.
+
+        Returns:
+            the provider itself for chaining purposes
+        """
+        self.bind(source, interface=interface, scope=Scope.APP, when=when, cache=True)
+        return self
+
+    def instance(
+        self,
+        value: object,
+        *,
+        interface: type | None = None,
+        when: BaseMarker | None = None,
+    ) -> Self:
+        """Binds an object that already exists.
+
+        Nothing is constructed: the value handed in is what every resolution
+        returns. Use it for configuration objects, clients built during boot,
+        and test doubles.
+
+        Args:
+            value: The object to hand out.
+            interface: The type to resolve it as. Defaults to `type(value)`.
+            when: Marker gating this binding.
+
+        Returns:
+            the provider itself for chaining purposes
+        """
+        self.bind(
+            lambda: value,
+            interface=interface if interface is not None else type(value),
+            scope=Scope.APP,
+            when=when,
+            cache=True,
+        )
+        return self
+
     def scoped(
         self,
         source: type | Callable[..., Any],
@@ -124,10 +199,10 @@ class ServiceProvider(abc.ABC):
         interface: type | None = None,
         when: BaseMarker | None = None,
     ) -> Self:
-        """Binds the source to the container.
+        """Binds the source at REQUEST scope.
 
-        Scope is REQUEST by default but a custom scope be provided.
-        Dependency declared with this are cached no matter what.
+        One instance is created per request scope and cached for its duration.
+        For any other scope, call `bind` with an explicit `scope`.
 
         Returns:
             the provider itself for chaining purposes

neva/config/loader.py

@@ -14,6 +14,11 @@ from neva.support import Err, Ok, Option, Result
 from neva.support.accessors import get_attr
 
 
+# Deliberately not "neva.config": a config file named repository.py or
+# loader.py would otherwise displace the real module of that name.
+_CONFIG_MODULE_NAMESPACE = "neva._app_config"
+
+
 class ConfigLoader:
     """Loads configuration files from a directory.
 
@@ -90,15 +95,22 @@ class ConfigLoader:
         """
         try:
             spec = importlib.util.spec_from_file_location(
-                f"neva.config.{module_name}", file_path
+                f"{_CONFIG_MODULE_NAMESPACE}.{module_name}", file_path
             )
 
             if spec is None or spec.loader is None:
                 return Err(f"Could not load module spec for {file_path}")
 
             module = importlib.util.module_from_spec(spec)
+            # Registered so dataclasses, pickle and typing lookups inside the
+            # config file can resolve it, then removed: these are data files,
+            # not importable modules, and leaving them in place would let a
+            # second config directory shadow the first.
             sys.modules[spec.name] = module
-            spec.loader.exec_module(module)
+            try:
+                spec.loader.exec_module(module)
+            finally:
+                _ = sys.modules.pop(spec.name, None)
 
             config_dict = self._extract_config(module)
             return Ok(config_dict)

neva/config/repository.py

@@ -5,6 +5,7 @@ store for all application configuration values. It supports dot notation for
 nested access and can be frozen to prevent modifications after initialization.
 """
 
+import copy
 from typing import Any, cast
 
 from typing_extensions import TypeForm
@@ -105,10 +106,11 @@ class ConfigRepository:
         """Get all configuration items as a dictionary.
 
         Returns:
-            A copy of the entire configuration dictionary.
+            A deep copy of the entire configuration dictionary. Mutating it
+            never reaches the repository, frozen or not.
 
         """
-        return self._items.copy()
+        return copy.deepcopy(self._items)
 
     def freeze(self) -> None:
         """Freeze the configuration to prevent further changes.
@@ -130,8 +132,10 @@ class ConfigRepository:
     def merge(self, key: str, items: dict[str, Any]) -> Result[None, str]:
         """Merge items into a configuration namespace.
 
-        Updates the dictionary at the given key with the provided items.
-        Creates the namespace if it doesn't exist.
+        Merges recursively: nested dictionaries are combined rather than
+        replaced, so a package can register defaults and an application can
+        override individual leaves without restating the whole namespace.
+        Non-dict values are replaced outright.
 
         Args:
             key: The namespace key to merge into.
@@ -153,5 +157,20 @@ class ConfigRepository:
                 f"existing value is {type(self._items[key]).__name__}, not dict"
             )
 
-        self._items[key].update(items)
+        _deep_merge(self._items[key], items)
         return Ok(None)
+
+
+def _deep_merge(target: dict[str, Any], source: dict[str, Any]) -> None:
+    """Merge source into target in place, recursing into nested dictionaries.
+
+    Args:
+        target: The dictionary to merge into. Modified in place.
+        source: The dictionary to read from.
+    """
+    for key, value in source.items():
+        existing = target.get(key)
+        if isinstance(existing, dict) and isinstance(value, dict):
+            _deep_merge(existing, value)
+        else:
+            target[key] = value

neva/database/connection.py

@@ -63,6 +63,20 @@ class TransactionContext:
             return Some(registry.stack[-1])
         return Nothing()
 
+    def outermost(self) -> Option[BoundTransaction]:
+        """Get the outermost open transaction, across all connections.
+
+        This is the last one to commit, so work that must not outlive *any*
+        open transaction — a deferred event listener — belongs on it.
+
+        Returns:
+            The outermost transaction, if any.
+        """
+        registry = _tx_registry.get()
+        if registry is None or not registry.stack:
+            return Nothing()
+        return Some(registry.stack[0])
+
 
 @final
 class ConnectionManager:
@@ -95,53 +109,52 @@ 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.
+
+        The registry may be unset in the current context: ``TransactionContext``
+        seeds it when it is constructed, and a task that did not inherit that
+        context — an ASGI request, when the lifespan ran on its own task — sees
+        the ``None`` default. Seed a fresh registry in that case, but still put
+        the transaction in it.
 
         Yields:
             None
         """
-        old_registry = _tx_registry.get()
-        token = (
-            _tx_registry.set(old_registry.extend(tx))
-            if old_registry is not None
-            else _tx_registry.set(TransactionRegistry())
-        )
+        old_registry = _tx_registry.get() or TransactionRegistry()
+        token = _tx_registry.set(old_registry.extend(tx))
         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 +175,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)

neva/database/manager.py

@@ -68,6 +68,17 @@ class DatabaseManager:
         """
         return self._tx_context.current(connection)
 
+    def outermost(self) -> Option[BoundTransaction]:
+        """Returns the outermost open transaction, across all connections.
+
+        Unlike `current`, which returns the most recently opened transaction,
+        this returns the one that commits last.
+
+        Returns:
+            The outermost transaction, if any.
+        """
+        return self._tx_context.outermost()
+
     def session(self, connection: str | None = None) -> Option[asyncio.AsyncSession]:
         """Returns the current session for a connection.
 

neva/database/provider.py

@@ -17,8 +17,8 @@ class DatabaseServiceProvider(ServiceProvider):
 
     @override
     def register(self) -> Result[Self, str]:
-        self.bind(TransactionContext)
-        self.bind(DatabaseManager)
+        _ = self.singleton(TransactionContext)
+        _ = self.singleton(DatabaseManager)
         return Ok(self)
 
     @asynccontextmanager
@@ -29,13 +29,15 @@ class DatabaseServiceProvider(ServiceProvider):
         logger.info("Beginning SQLAlchemy initialization...")
         match self.app.config.get("database", type_=DatabaseConfig):
             case Ok(config):
-                connections: dict[str, ConnectionConfig] = config["connections"]
+                connections: dict[str, ConnectionConfig] = config.get("connections", {})
                 for name, conn_config in connections.items():
                     db.register_connection(name, conn_config)
                     logger.info(f"Registered engine for connection '{name}'.")
                 logger.info("SQLAlchemy initialization complete.")
-                yield
-                await db.close()
             case Err(err):
                 logger.error(f"Failed to load database configuration: {err}")
-                yield
+
+        try:
+            yield
+        finally:
+            await db.close()

neva/database/transaction.py

@@ -1,6 +1,5 @@
 """Transaction management systems."""
 
-import abc
 import asyncio
 from collections.abc import Awaitable
 from dataclasses import dataclass, field
@@ -24,7 +23,7 @@ class TransactionState(Enum):
 
 
 @dataclass
-class Transaction(abc.ABC):
+class Transaction:
     """Represents a database transaction with callback support."""
 
     conn_name: str

neva/events/contracts/__init__.py

@@ -1,3 +1,5 @@
+"""Protocols describing the event system's public contracts."""
+
 from neva.events.contracts.dispatcher import (
     AsyncBeforeDispatchHook,
     BeforeDispatchHook,

neva/events/dispatcher.py

@@ -7,7 +7,7 @@ from neva.arch.application import Application
 from neva.database.manager import DatabaseManager
 from neva.database.transaction import TransactionCallback
 from neva.events import contracts
-from neva.events.event_registry import EventRegistry
+from neva.events.event_registry import EventRegistry, flatten_listeners
 from neva.support import Err, Nothing, Result, Some
 
 
@@ -52,27 +52,30 @@ class EventDispatcher(contracts.EventDispatcher):
         Listeners are resolved from the DI container when available,
         falling back to direct instantiation otherwise.
 
+        Deferred listeners are attached to the outermost open transaction —
+        the last one to commit — so they never run for work an enclosing
+        transaction may still roll back.
+
         Args:
             event: The event to dispatch.
 
         Returns:
-            A list of results, one per listener invocation.
+            A list of results, one per immediate listener invocation. Deferred
+            listeners report through the transaction's callback log instead.
         """
         await self._apply_before_dispatch(event)
         results: list[Result[None, str]] = []
-        listeners = self._registry.resolve_listeners(event)
+        registries = self._registry.resolve_listeners(event)
 
-        immediate: list[type[contracts.EventListener[contracts.Event]]] = []
-        deferred: list[type[contracts.EventListener[contracts.Event]]] = []
-        [immediate.extend(listener.immediate.copy()) for listener in listeners]
-        [deferred.extend(listener.deferred.copy()) for listener in listeners]
+        immediate = flatten_listeners(registries, deferred=False)
+        deferred = flatten_listeners(registries, deferred=True)
 
-        match self._db.current():
+        match self._db.outermost():
             case Some(tx):
                 for listener_cls in deferred:
                     _ = tx.on_commit(self._build_callback(event, listener_cls))
             case Nothing():
-                immediate.extend(deferred)
+                immediate.extend(d for d in deferred if d not in immediate)
 
         for listener_cls in immediate:
             listener = self._resolve_listener(listener_cls)

neva/events/event_registry.py

@@ -46,14 +46,51 @@ class EventRegistry:
             )
 
     def resolve_listeners(self, event: T) -> list[EventListenerRegistry[T]]:
-        """Return all listeners registries for an event type."""
-        registries = [
+        """Return all listener registries for an event type, most specific first.
+
+        Walks the MRO so a listener registered against a base event also
+        handles its subclasses. Callers must flatten these with
+        `flatten_listeners` rather than concatenating them, or a listener
+        registered against both a class and its parent runs twice.
+        """
+        return [
             self.__listeners[cls]
             for cls in inspect.getmro(type(event))
             if cls in self.__listeners
         ]
-        return registries
 
     def get_listeners(self, event: T) -> EventListenerRegistry[T]:
         """Return all listeners registered for an event type."""
         return self.__listeners.get(type(event), EventListenerRegistry[T]())
+
+
+def flatten_listeners[E: contracts.Event](
+    registries: list[EventListenerRegistry[E]],
+    *,
+    deferred: bool,
+) -> list[type[contracts.EventListener[E]]]:
+    """Collapse listener registries into one ordered, duplicate-free list.
+
+    Args:
+        registries: Registries for an event, most specific first.
+        deferred: Select the deferred bucket rather than the immediate one.
+
+    Returns:
+        The listener classes to invoke, most-specific registry first. A listener
+        reached through more than one registry appears only once; repeated
+        registrations against the same event are preserved.
+    """
+    flattened: list[type[contracts.EventListener[E]]] = []
+    covered: set[type[contracts.EventListener[E]]] = set()
+
+    for registry in registries:
+        bucket = registry.deferred if deferred else registry.immediate
+        # Duplicates *within* one registry are explicit repeat registrations
+        # and are honoured. Duplicates *across* registries come from the MRO
+        # walk — one listener registered against both a class and its parent —
+        # and must collapse to the registrations already counted.
+        fresh = [cls for cls in bucket if cls not in covered]
+        flattened.extend(fresh)
+        covered.update(fresh)
+
+    return flattened

neva/events/listener.py

@@ -15,7 +15,7 @@ class EventListener[T: contracts.Event](contracts.EventListener[T]):
     policy: HandlingPolicy = HandlingPolicy.IMMEDIATE
 
     @override
-    async def handle(self, event: contracts.Event) -> Result[None, str]: ...
+    async def handle(self, event: T) -> Result[None, str]: ...
 
 
 def listener[T: contracts.Event](
@@ -37,11 +37,10 @@ def listener[T: contracts.Event](
             namespace["handle"] = handle
             namespace["policy"] = policy
 
-        # Ty struggles with infering type here, hence the type: ignore
         return new_class(
             snake2pascal(func.__name__) + "Listener",
             (EventListener[T],),
             exec_body=exec_body,
-        )  # type: ignore[invalid-return-type]
+        )
 
     return decorator

neva/events/provider.py

@@ -24,7 +24,7 @@ class EventServiceProvider(ServiceProvider):
         Returns:
             Result[Self, str]: The result of the registration.
         """
-        self.bind(EventRegistry)
-        self.bind(EventDispatcher)
-        self.bind(EventDispatcher, interface=contracts.EventDispatcher)
+        _ = self.singleton(EventRegistry)
+        _ = self.singleton(EventDispatcher)
+        _ = self.singleton(EventDispatcher, interface=contracts.EventDispatcher)
         return Ok(self)

neva/obs/logging/provider.py

@@ -21,6 +21,6 @@ class LogServiceProvider(ServiceProvider):
 
     @override
     def register(self) -> Result[Self, str]:
-        self.bind(LogManager)
+        _ = self.singleton(LogManager)
 
         return Ok(self)

neva/polyfactory/__init__.py

@@ -1,3 +1,5 @@
+"""Polyfactory helpers for building and persisting model factories."""
+
 from neva.polyfactory.factories import ModelFactory
 
 

neva/security/hashing/hash_manager.py

@@ -1,5 +1,6 @@
 """Hash manager for managing password hashing strategies."""
 
+import asyncio
 from typing import override
 
 from neva.arch import Application
@@ -78,6 +79,52 @@ class HashManager(StrategyResolver[Hasher]):
         )
         return hasher_instance.check(plaintext, hashed)
 
+    async def make_async(
+        self,
+        plaintext: str | bytes,
+        *,
+        salt: bytes | None = None,
+        hasher: str | None = None,
+    ) -> str:
+        """Hash a plaintext password on a worker thread.
+
+        Password hashing is deliberately CPU- and memory-expensive — argon2
+        defaults to 100 MiB and tens of milliseconds — so calling `make` from
+        a coroutine stalls the whole event loop. Prefer this in async code.
+
+        Args:
+            plaintext: The password to hash.
+            salt: Optional salt for the hash.
+            hasher: Name of the hasher to use (defaults to configured hasher).
+
+        Returns:
+            The hashed password string.
+        """
+        return await asyncio.to_thread(self.make, plaintext, salt=salt, hasher=hasher)
+
+    async def check_async(
+        self,
+        plaintext: str | bytes,
+        hashed: str | bytes,
+        *,
+        hasher: str | None = None,
+    ) -> bool:
+        """Verify a password against a hashed value on a worker thread.
+
+        Verification costs the same as hashing by design. Prefer this over
+        `check` in async code — a login endpoint calling `check` blocks every
+        other request on the loop for the duration.
+
+        Args:
+            plaintext: The plaintext password to verify.
+            hashed: The hashed password to verify against.
+            hasher: Name of the hasher to use (defaults to configured hasher).
+
+        Returns:
+            True if the password matches, False otherwise.
+        """
+        return await asyncio.to_thread(self.check, plaintext, hashed, hasher=hasher)
+
     def needs_rehash(
         self,
         hashed: str | bytes,
@@ -109,7 +156,7 @@ class HashManager(StrategyResolver[Hasher]):
         """
         argon_config = manager.app.config.get(
             "hashing.argon", type_=Argon2Config
-        ).unwrap()
+        ).unwrap_or(Argon2Config())
 
         return Argon2Hasher(
             time_cost=argon_config.get("time_cost", 2),
@@ -130,7 +177,7 @@ class HashManager(StrategyResolver[Hasher]):
         """
         bcrypt_config = manager.app.config.get(
             "hashing.bcrypt", type_=BcryptConfig
-        ).unwrap()
+        ).unwrap_or(BcryptConfig())
 
         return BcryptHasher(
             rounds=bcrypt_config.get("rounds", 12),

neva/security/hashing/hashers/bcrypt.py

@@ -13,7 +13,7 @@ class BcryptHasher(Hasher):
     def __init__(
         self,
         rounds: int = 12,
-        prefix: Literal["2a", "2b"] = "2a",
+        prefix: Literal["2a", "2b"] = "2b",
     ) -> None:
         """Initialize the hasher."""
         self._hasher: PwdLibBcryptHasher = PwdLibBcryptHasher(rounds, prefix)

neva/security/provider.py

@@ -13,6 +13,6 @@ class SecurityProvider(arch.ServiceProvider):
 
     @override
     def register(self) -> Result[Self, str]:
-        self.bind(HashManager, interface=HashManager)
-        self.bind(AesEncrypter, interface=Encrypter)
+        _ = self.singleton(HashManager, interface=HashManager)
+        _ = self.singleton(AesEncrypter, interface=Encrypter)
         return Ok(self)

neva/support/facade/config.pyi

@@ -2,6 +2,8 @@
 
 from typing import Any, override
 
+from typing_extensions import TypeForm
+
 from neva.arch import Facade
 from neva.support import Result
 
@@ -26,15 +28,16 @@ class Config(Facade):
         ...
 
     @classmethod
-    def get(cls, key: str, default: object = None) -> Result[Any, str]:
+    def get[T](cls, key: str, type_: TypeForm[T] | None = None) -> Result[T, str]:
         """Get a configuration value using dot notation.
 
         Args:
             key: Dot-notated key path (e.g., "database.host").
-            default: Default value to return if key is not found.
+            type_: Type to cast the value to. This is a cast, not validation.
 
         Returns:
-            Result containing the configuration value or the default.
+            Result containing the configuration value, or an error if absent.
+            Supply a fallback with `Config.get(key).unwrap_or(default)`.
 
         """
         ...

neva/support/facade/hash.pyi

@@ -1,4 +1,4 @@
-"""Type stop for Hash facade."""
+"""Type stub for Hash facade."""
 
 from typing import override
 
@@ -46,6 +46,50 @@ class Hash(Facade):
             True if the password matches, False otherwise.
         """
 
+    @classmethod
+    async def make_async(
+        cls,
+        plaintext: str | bytes,
+        *,
+        salt: bytes | None = None,
+        hasher: str | None = None,
+    ) -> str:
+        """Hash a plaintext password on a worker thread.
+
+        Prefer this over `make` in async code: hashing is deliberately
+        expensive and blocks the event loop for its whole duration.
+
+        Args:
+            plaintext: The password to hash.
+            salt: Optional salt for the hash.
+            hasher: Name of the hasher to use (defaults to configured hasher).
+
+        Returns:
+            The hashed password string.
+        """
+
+    @classmethod
+    async def check_async(
+        cls,
+        plaintext: str | bytes,
+        hashed: str | bytes,
+        *,
+        hasher: str | None = None,
+    ) -> bool:
+        """Verify a password against a hashed value on a worker thread.
+
+        Prefer this over `check` in async code: verification costs the same as
+        hashing by design.
+
+        Args:
+            plaintext: The plaintext password to verify.
+            hashed: The hashed password to verify against.
+            hasher: Name of the hasher to use (defaults to configured hasher).
+
+        Returns:
+            True if the password matches, False otherwise.
+        """
+
     @classmethod
     def needs_rehash(
         cls,

python_neva-3.6.0.dist-info/METADATA

@@ -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.5.0.dist-info → python_neva-3.6.0.dist-info}/RECORD

@@ -1,34 +1,34 @@
 neva/arch/__init__.py,sha256=1ukTl5Ynz5PrGa5e-tFSMaNgVkfhQRrYQGPUqUeXMMg,429
-neva/arch/application.py,sha256=DH1CXVEsiOCDQIigOXfXI2jYGVZr-TwMgilTQu6qPq0,7258
-neva/arch/config.py,sha256=R8_wMKTwX8vTFqfQhgglDQ9PfB6Yo6mx6OnKg8bnIWw,1042
+neva/arch/application.py,sha256=PQ5Zb29kwt6srDArnDrxwOjc62MYutQTmhlUCQ5wSlQ,9968
+neva/arch/config.py,sha256=k8Nf5kBfw0We-gFxPqDEi78T8eFHBhZe1qTpCi2Q0kA,1054
 neva/arch/facade.py,sha256=1kYVhyYto8zSyOZV6sAYJ3xWzQDJRzoVV-e_EarTp0Q,7927
 neva/arch/markers.py,sha256=STdhmW88qV8uogIa9kSD9gs-uMRaglZI8HOw3PrhX1Q,103
 neva/arch/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-neva/arch/scopes.py,sha256=Gu0kJk39Yv8LCCzxjdu0lIE0FXtnsG36LGKDuNin2CE,87
-neva/arch/service_provider.py,sha256=SqL3uQGBh7aDIc_Lcp8Ijr3fdOtB8wbsmMnjU4GuUy4,5862
+neva/arch/scopes.py,sha256=9sc1nIVeODQzAtNwvSUWiij6IIssNyOaKW2CNknBgTo,86
+neva/arch/service_provider.py,sha256=BRHMHuG3SRbVzQUipNaKgNQmn9GVUk5VO3Nart1JmnI,8630
 neva/arch/integrations/__init__.py,sha256=cXuqC4JfZdGYLlh6POgYUVXUT2NQ84276eC-RYTyFxk,75
 neva/arch/integrations/faststream.py,sha256=AOwfpfdL3O5HLAx80SwUGQb_hKEeAkFOUyIXtjODaHM,1696
 neva/config/__init__.py,sha256=Ygfnh-MRRKYDdf54_LeMSHwmck5VpNHTdnnMtGEFLtU,121
 neva/config/base_providers.py,sha256=vXv3kGWnrWQGBMo4WvEmYnryCKLkOdFFTjrDFDnhXFI,909
-neva/config/loader.py,sha256=WGXJDc7fjPc7QvnnBLdSkHkBgxND6x0cvwWpCNdpbPg,3950
+neva/config/loader.py,sha256=E81a6nEboRNNMBEFU26UvEgvAjPIN3Aqn6mmVpa5cf4,4534
 neva/config/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-neva/config/repository.py,sha256=-6lG0LcAO30OoJ9vSS4U1xO2o8-EWhSib5_CVEiZkyk,4750
+neva/config/repository.py,sha256=p8PjTfjV23ioy_iyb5b6oYPnYq1bVe6q6gVRSegJr7Q,5505
 neva/database/__init__.py,sha256=3yYnEe8HQM86tURyAhTbMtE7AXubIEMN3GuwxkkT-bk,508
 neva/database/config.py,sha256=bVKUqlrYDFrURqg_FbntPXyVkbOUPSVXQJTKjyucjL0,451
-neva/database/connection.py,sha256=7bETJ9wXb6_lwbazG25XDTuGKKKaEmetBTSI9JdM94Q,6308
-neva/database/manager.py,sha256=VNvhVumZD2hoGKpkdXMAkT6KykE4H80WcG2DgShK5Hs,4240
-neva/database/provider.py,sha256=l2be4Ri53RtQq1-qzohy3cqzJQpTaNzqXGVhXPKUCXc,1674
+neva/database/connection.py,sha256=iosVrpzZxG4WS3fNSdUwiO2-aTH1hR960PkiAefuBqI,6980
+neva/database/manager.py,sha256=yPbDMcVlsn5_8ISPVhyajAM42i34r2gJgI9o-TVp59c,4617
+neva/database/provider.py,sha256=XCi8-mfJ5KDVpVO10YlNX4jt0a9ESSeTyn8o3ohOe9c,1701
 neva/database/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-neva/database/transaction.py,sha256=_0Dsao_vhCJT5YRUmrHOLb0uxvfdE-5k3n0yMPLC1o8,5167
+neva/database/transaction.py,sha256=tUJ_WrAsw9ZSHTHYhlxSpSKYxAkKKbZky-GhDMXA3CY,5147
 neva/events/__init__.py,sha256=Gpi5q-pNlIi-q23U2ZOsNf8Y9rB6AQtsBbbBFU0tkFc,776
-neva/events/dispatcher.py,sha256=KR5uDZbnNwrMCI6s9S_SoNrNHx2z2lugoHk1-g3fzXA,4288
+neva/events/dispatcher.py,sha256=O_sDpbQBRMFg34hoXEtIfWhYVX-_QUjYB0Nk4QXOGsM,4453
 neva/events/event.py,sha256=q-KyyxNkU3AN2YSaujuNPIoXQMXhGOwClTap5y8fU5I,282
-neva/events/event_registry.py,sha256=IZnpR3oLyvt5K2pn9KMCBw5W4JP7Ok_zMKI2SgQoXVM,1945
-neva/events/listener.py,sha256=2d5RHVKO0pU-eL_evLReTG0DIoX9tZyOcn8PWLeECZo,1435
+neva/events/event_registry.py,sha256=lMimggnMrz3CCQqM0lNZX1xDPPwuU1Auu9c4_UaBluI,3523
+neva/events/listener.py,sha256=d9Z0jGAnH8swpVcCbZ_C7v17dCJaGs5OzBoV2OttTtI,1313
 neva/events/policy.py,sha256=I67ziob0IEVeXdkilNPpj2f48gEz2EZneR1Fz8Nlt2U,154
-neva/events/provider.py,sha256=cVxADLv7VXCK6gTMJsDNRzspMOH2lrIkvMRhqVh2cK4,954
+neva/events/provider.py,sha256=-6PmL3oU9Tc6hJj0Glvdl5lOyNTLsuD6YEcnQSkiyEA,981
 neva/events/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-neva/events/contracts/__init__.py,sha256=t1VafYtzOZIF78V8X3K_Fg79Hw4FjSqasjLs0EQVIFA,489
+neva/events/contracts/__init__.py,sha256=_-DpJpfszRHHMQR8dcyS8_cfX_NZwfBSMbl8cEnvFbc,554
 neva/events/contracts/dispatcher.py,sha256=pzCv_ZLS5ju2IKVMxL5f-fFipEqQZc6zPiIVtJhKJHc,1274
 neva/events/contracts/event.py,sha256=kUUECex_AlmaPJ-fXRg32eMkiqNS75CHldOr7bbpFqo,89
 neva/events/contracts/handler.py,sha256=SwLuuRtXhCzGkcBBLdH3MjUAkjEr0_rhqgE6dkWVJxI,327
@@ -39,26 +39,26 @@ neva/obs/instrumentation/__init__.py,sha256=SfIAvuCs-L0kEzOxUJ4aOIkhbydCe7qBwWtG
 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=M-oH-5oytsdUDICvCnb6trDcU0mw-n8t2iWfiWmo_k0,642
+neva/obs/logging/provider.py,sha256=-AIZb60PmTpvO9PtsJwZ5FJeTC_Yn6ik8DdJCHULpV0,651
 neva/obs/middleware/__init__.py,sha256=WbZ-Pr_fVl6T8LfQRyC_YXMlN7WaQKEwX8KUvGiLOBc,182
 neva/obs/middleware/correlation.py,sha256=x_3HtlBV1Qe8JRgGpEwSTXvKkeCgWal15b0hrFjNAJs,2034
 neva/obs/middleware/profiler.py,sha256=ovx3s-39WpNtu2KhzVMWyIJa6OLrSVDuL56xyDA-vQ4,1942
-neva/polyfactory/__init__.py,sha256=jA4sQHmFn0NLIAiC1zYrORyp9M9hqb-QFCGBPp0YXXo,81
+neva/polyfactory/__init__.py,sha256=t7uAXaleAyshSyBdGXNzvgY0nNpb5AqFU4zjE8lyKyk,153
 neva/polyfactory/factories.py,sha256=8VoZJlY0-_ZOM8rmfUcvEbt-KOZsaDj8f6R5EQF62u8,600
 neva/polyfactory/persistence.py,sha256=1qBg8L_xkiRFq6J2XoZFez43oxNWDaUM8SrlNAeOkQA,605
 neva/polyfactory/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 neva/security/__init__.py,sha256=Dhh3ZsseP6biWgRQY4hYKkoYFCR7ehhxz4VBqN8e02k,440
-neva/security/provider.py,sha256=5b4F6JdzoshVWr1HcdX76yPgyUES_Rf08QxkAfl9vyw,515
+neva/security/provider.py,sha256=6GqSzAsgHtOEnkQFmd0Dusgbv65QhJRxOEBfmObspmc,533
 neva/security/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 neva/security/encryption/__init__.py,sha256=eVWW-qk03vy7Bn-sNQ2WJHWZI6tPJOkknJz8llc1m0M,288
 neva/security/encryption/encrypter.py,sha256=YiJrLmv2C_CkqU3eZDvBHnkwA5zzjb6T3-X2kThywZs,5152
 neva/security/encryption/protocol.py,sha256=pZtkTCz0k6eUX0fivJrvb7yDXy2eTAg--ZbCXhfUXWc,847
 neva/security/hashing/__init__.py,sha256=k3SviEvtJLjBXTkR5I6w9YMPw6Q-LIoE1wGNz3GYvOE,374
 neva/security/hashing/config.py,sha256=ltj7_GW44gSg2N0i8CEYaw6Y6xUfzwsr4zXk5ic_sJI,624
-neva/security/hashing/hash_manager.py,sha256=mvZTYiPbv_s10aCxii3EyjSRylaRju7AX-F7PX8Iozo,4444
+neva/security/hashing/hash_manager.py,sha256=F55T1xcQpIEV3A52L4KeAbkUeS7ogCgm8lI79RUJP_M,6123
 neva/security/hashing/hashers/__init__.py,sha256=Zn_Q2tj_8lhhwJRZ7RXeJLYujd-3j7Rr8JQO2sSGgJs,44
 neva/security/hashing/hashers/argon2.py,sha256=pJqTl3_oCJCjJarnQwNSFRznlaijjbjdDVpC0DXDoSg,1402
-neva/security/hashing/hashers/bcrypt.py,sha256=H_15r-z9DYkd4HEbTz0QA4NHVBiFDXEqHkngP3HMSBY,1083
+neva/security/hashing/hashers/bcrypt.py,sha256=-VsCtbQvEFDoKnwQxUwYFGSI_1qyWfP3R5TAhNvZW0Q,1083
 neva/security/hashing/hashers/protocol.py,sha256=aVGMO2q3H-u8uyGPt6mIy1Dq7pW0k4WjtHi0nnKsgCQ,611
 neva/security/tokens/__init__.py,sha256=H1SWLWa4btJqc0wBUFTdKUYmBgXYZYnCitG1BsbLtqI,235
 neva/security/tokens/generate_token.py,sha256=xqlC80IfCvkwmQR_TAHmEntiJdEV2yEPHX6qBnv5cBg,334
@@ -75,7 +75,7 @@ neva/support/facade/__init__.py,sha256=aysM4AyDAxAgv8uZCka49t2vLHeVraTNAHeCIpXLd
 neva/support/facade/app.py,sha256=xdL9qpeQnJtAMomxfrImM82qM2YV2eQFsckmUNE2w7I,297
 neva/support/facade/app.pyi,sha256=gTAKp_r8DUqOj-oggAyAuK1WvR2AzX63-G2U5NixHbM,1304
 neva/support/facade/config.py,sha256=cqmtwAekHE4qWH2LqzmY3BAbyAadvZYfPgLHyTcCnJE,358
-neva/support/facade/config.pyi,sha256=LpI6xwqURRlWPcohXBxTL-iWTHq3MMMNdu670Q_5jnk,2549
+neva/support/facade/config.pyi,sha256=HwXd4JG43-Ep8XckrYUkltQZyb73pOzzxFJRsV-iNJk,2693
 neva/support/facade/crypt.py,sha256=BUx2woDla3TrvVOVRNzOg97zfCaXIOqIz5EdoN3BvlA,298
 neva/support/facade/crypt.pyi,sha256=_MV_qXDATaCs1pZTOw_-qPx_jjH_nG4-tUBOMX4nZIE,857
 neva/support/facade/db.py,sha256=mXMzuCKf390ICCBgzaub1ZoMqUBgOQByQYMEM3YnN_0,324
@@ -83,7 +83,7 @@ neva/support/facade/db.pyi,sha256=UQFMgBuw0BGquMnuUNULC8Pdo7lDCVTCNkDaUmIZJhw,19
 neva/support/facade/event.py,sha256=BkJoof1hYTxhMBOxLrq21NIgEPIiLBlj18Pttl0FHa8,1236
 neva/support/facade/event.pyi,sha256=7R6osyTZbHt_zkCfQ-uZnTLfyZTeN1bi3exsgl3-36k,817
 neva/support/facade/hash.py,sha256=tGhsvfGovt-mcRXSjDKf4jt1n7ib0eDPXFvRUfVxLUc,292
-neva/support/facade/hash.pyi,sha256=jTs3E5ZF5cp76jrgH70DEog8gzfYIcIV2PrO9xskHyI,1656
+neva/support/facade/hash.pyi,sha256=Uy0CkV67MImPjHc6BmmLQPd7qF1QNDtO1oDFyyRr-1A,2950
 neva/support/facade/log.py,sha256=_uLoHB9tkpHkiqEJXazbaqfiKUOtv3NS71ZCZAprzOI,347
 neva/support/facade/log.pyi,sha256=Xi7gIzw9qRqmD4D3PcW06_HUtgLWEOdsHqs1B0jh1-k,1647
 neva/testing/__init__.py,sha256=vt5zxG1N84vn_YwP44jhYPWYnyb02-cha3m-1l-qoEw,207
@@ -91,6 +91,6 @@ neva/testing/fakes.py,sha256=w2dnFaO6x14l0_si7iBNELMCxaFi8VsVOSQ6PmTlclE,2936
 neva/testing/fixtures.py,sha256=oiPa5ntUkW-SbySDvwEHXtti8NqSwI-R0CT1_ezTx_Y,1445
 neva/testing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 neva/testing/test_case.py,sha256=zJBZJeKI-sv-EOaXNuSJ0V2Zp_6hdk64W4dOh0eP8RI,3290
-python_neva-3.5.0.dist-info/METADATA,sha256=rcHS4PoUAyXqpkmfej_UhyUaBgnb5dV-x8ZbwMWbXFQ,846
-python_neva-3.5.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-python_neva-3.5.0.dist-info/RECORD,,
+python_neva-3.6.0.dist-info/METADATA,sha256=0T-O4BAsX8clep5cWzsahGMrn6M7REDxU65agpbKSik,5029
+python_neva-3.6.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+python_neva-3.6.0.dist-info/RECORD,,

{python_neva-3.5.0.dist-info → python_neva-3.6.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.30.1
+Generator: hatchling 1.32.0
 Root-Is-Purelib: true
 Tag: py3-none-any

python_neva-3.5.0.dist-info/METADATA

@@ -1,27 +0,0 @@
-Metadata-Version: 2.4
-Name: python-neva
-Version: 3.5.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
-
-# The Neva framework
-
-PLACEHOLDER