python-neva 2.4.1__tar.gz → 3.1.0__tar.gz

{python_neva-2.4.1 → python_neva-3.1.0}/.pre-commit-config.yaml

@@ -27,3 +27,19 @@ repos:
     hooks:
       - id: mypy
         args: [--enable-incomplete-feature=TypeForm]
+        additional_dependencies:
+          [
+            cryptography>=46.0.3,
+            dishka>=1.10.0,
+            "fastapi[all]>=0.129.0",
+            faststream>=0.6.6,
+            "pwdlib[argon2,bcrypt]>=0.3.0",
+            pyinstrument>=5.1.1,
+            pytest>=9.0.2,
+            structlog>=25.5.0,
+            "sqlalchemy[asyncio]>=2.0.0",
+            asyncpg>=0.30.0,
+            aiosqlite>=0.20.0,
+            typer>=0.21.1,
+            opentelemetry-instrumentation-sqlalchemy>=0.62b0,
+          ]

python_neva-3.1.0/CHANGELOG.md

@@ -0,0 +1,42 @@
+## 3.1.0 (2026-05-11)
+
+### ✨ Features
+
+- fixing db facade
+- Add eq method to Some / Ok
+- Deprecate register_engine, add register_connection
+- RefreshDatabase now properly use the testcase inner app
+- Add neva-fastapi as optional dependency
+- renaming of make / make_async for retrocompatibility
+
+### 🐛🚑️ Fixes
+
+- Fix provider registration ordering
+
+### ♻️ Refactorings
+
+- refactor of results / db toolkit
+
+## 3.1.0a1 (2026-05-05)
+
+### build
+
+- add commitizen + versioningit
+
+### 💚👷 CI & Build
+
+- update perms on tag script
+- tweaking cz tags
+- remove auto-annotated tags
+- configure versioningit + cz
+- Fix cz config >>> ⏰ 1
+- add and configure cz_gitmoji >>> ⏰ 5m
+
+### 📝💡 Documentation
+
+- clear changelog
+
+### 🔧🔨📦️ Configuration, Scripts, Packages
+
+- improve auto-annotation of tags
+- Fix tagging script

{python_neva-2.4.1 → python_neva-3.1.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: python-neva
-Version: 2.4.1
+Version: 3.1.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.7.2
+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
@@ -15,6 +15,8 @@ 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>=0.1.0; extra == 'fastapi'
 Provides-Extra: testing
 Requires-Dist: pytest-asyncio>=0.25.3; extra == 'testing'
 Requires-Dist: pytest>=9.0.2; extra == 'testing'

{python_neva-2.4.1 → python_neva-3.1.0}/neva/arch/__init__.py

@@ -4,7 +4,6 @@ This module contains the main application class, service provider pattern,
 and facade implementations.
 """
 
-from neva.arch.app import App
 from neva.arch.application import Application
 from neva.arch.facade import Facade
 from neva.arch.service_provider import (
@@ -14,7 +13,6 @@ from neva.arch.service_provider import (
 
 
 __all__ = [
-    "App",
     "Application",
     "Bootable",
     "Facade",

{python_neva-2.4.1 → python_neva-3.1.0}/neva/arch/application.py

@@ -1,18 +1,26 @@
 """Base application for DI and facade injection."""
 
 import os
-from collections.abc import AsyncIterator, Iterator
-from contextlib import AsyncExitStack, asynccontextmanager, contextmanager
+from collections import OrderedDict
+from collections.abc import AsyncIterator, Sequence
+from contextlib import AsyncExitStack, asynccontextmanager
+from contextvars import ContextVar
 from pathlib import Path
 from typing import Any, Callable, Self
 
 import dishka
-from dishka.integrations.fastapi import FastapiProvider
+from dishka.provider import BaseProvider
+from typing_extensions import deprecated
 
-from neva import Err, Ok, Result
 from neva.arch.facade import Facade
 from neva.arch.service_provider import Bootable, ServiceProvider
 from neva.config.loader import ConfigLoader
+from neva.support import Err, Ok, Result
+
+
+_current_container: ContextVar["dishka.AsyncContainer"] = ContextVar(
+    "_current_container"
+)
 
 
 class Application:
@@ -32,8 +40,8 @@ class Application:
         from neva.config.repository import ConfigRepository
 
         self.config: ConfigRepository = ConfigRepository()
-        self.providers: dict[type, ServiceProvider] = {}
-        self.di_provider: dishka.Provider = dishka.Provider(scope=dishka.Scope.APP)
+        self.providers: OrderedDict[type, ServiceProvider] = OrderedDict()
+        self.root_provider: dishka.Provider = dishka.Provider(scope=dishka.Scope.APP)
 
         configuration_path = (
             config_path
@@ -50,25 +58,33 @@ class Application:
                 ):
                     raise RuntimeError("Failed to register config")
 
-                self.bind(lambda: self.config, interface=ConfigRepository)
+                _ = self.root_provider.provide(
+                    lambda: self.config, provides=ConfigRepository
+                )
 
-        providers_from_file: list[type[ServiceProvider]] = self.config.get(
-            "providers.providers", type_=list[type[ServiceProvider]]
-        ).unwrap_or([])
-        providers_from_app = self.config.get(
-            "app.providers", type_=list[type[ServiceProvider]]
-        ).unwrap_or([])
-        providers: set[type[ServiceProvider]] = set(providers_from_file).union(
-            set(providers_from_app)
+        providers: list[type[ServiceProvider]] = base_providers()
+        providers.extend(
+            self.config.get(
+                "providers.providers", type_=list[type[ServiceProvider]]
+            ).unwrap_or([])
         )
-        self.register_providers(base_providers().union(providers))
-        self.bind(source=lambda: self, interface=Application)
+        providers.extend(
+            self.config.get(
+                "app.providers", type_=list[type[ServiceProvider]]
+            ).unwrap_or([])
+        )
+        _ = self.root_provider.provide(source=lambda: self, provides=Application)
+        self.register_providers(providers)
         self._bind_event_listeners()
-        self.container: dishka.Container = dishka.make_container(self.di_provider)
-
-    def bind_to_fastapi(self) -> None:
-        """Setup the FastapiProvider for FastAPI integration."""
-        self.container = dishka.make_container(self.di_provider, FastapiProvider())
+        self.build_container(self.root_provider)
+
+    def build_container(self, *providers: BaseProvider) -> None:
+        """Build the application container."""
+        self.container: dishka.AsyncContainer = dishka.make_async_container(
+            self.root_provider,
+            *[p.provider for p in self.providers.values()],
+            *providers,
+        )
 
     def register(self, provider: type[ServiceProvider]) -> Result[ServiceProvider, str]:
         """Registers a service provider with the application.
@@ -85,11 +101,12 @@ class Application:
             .map(lambda p: self.providers.setdefault(provider, p))
         )
 
-    def register_providers(self, providers: set[type[ServiceProvider]]) -> None:
+    def register_providers(self, providers: Sequence[type[ServiceProvider]]) -> None:
         """Registers a set of providers."""
         for provider in providers:
             _ = self.register(provider)
 
+    @deprecated("Use the new bind() method directly with a Service Provider.")
     def bind(
         self,
         source: type | Callable[..., Any],
@@ -98,37 +115,50 @@ class Application:
         scope: dishka.BaseScope | None = None,
     ) -> None:
         """Binds a source to the container."""
-        _ = self.di_provider.provide(
+        _ = self.root_provider.provide(
             source=source,
             scope=scope,
             provides=interface,
         )
 
-    def make[T](self, interface: type[T]) -> Result[T, str]:
+    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))
+        except Exception as e:
+            return Err(f"Failed to resolve service '{interface.__name__}': {e}")
+
+    def make[T](self, interface: type[T]) -> Result[T, str]:
+        """Synchronous version of make.
+
+        Returns:
+            Result containing the resolved type instance or an error message.
+        """
+        container = _current_container.get(self.container)
         try:
-            return Ok(self.container.get(interface))
+            return Ok(container.get_sync(interface))
         except Exception as e:
             return Err(f"Failed to resolve service '{interface.__name__}': {e}")
 
-    @contextmanager
-    def scope(self, scope: dishka.BaseScope | None = None) -> Iterator[Self]:
+    @asynccontextmanager
+    async def scope(self, scope: dishka.BaseScope | None = None) -> AsyncIterator[Self]:
         """Enter a new scope.
 
         Yields:
             The application instance with the new scope.
         """
-        parent = self.container
-        with self.container(scope=scope) as container:
-            self.container = container
+        parent = _current_container.get(self.container)
+        async with parent(scope=scope) as container:
+            token = _current_container.set(container)
             try:
                 yield self
             finally:
-                self.container = parent
+                _current_container.reset(token)
 
     @asynccontextmanager
     async def lifespan(self) -> AsyncIterator[None]:
@@ -140,9 +170,10 @@ class Application:
                 if isinstance(provider, Bootable):
                     await stack.enter_async_context(provider.lifespan())
 
-            self._wire_event_listeners()
+            await self._wire_event_listeners()
             yield
 
+        await self.container.close()
         Facade.reset_facade_application()
 
     def _bind_event_listeners(self) -> None:
@@ -152,11 +183,11 @@ class Application:
                 for listener_cls in listeners:
                     self.bind(listener_cls)
 
-    def _wire_event_listeners(self) -> None:
+    async def _wire_event_listeners(self) -> None:
         """Wire event-listener mappings from all providers onto the dispatcher."""
         from neva.events.dispatcher import EventDispatcher
 
-        result = self.make(EventDispatcher)
+        result = await self.make_async(EventDispatcher)
         if result.is_err:
             return
 

{python_neva-2.4.1 → python_neva-3.1.0}/neva/arch/facade.py

@@ -11,7 +11,7 @@ from contextlib import contextmanager
 from typing import TYPE_CHECKING, Any, ClassVar, cast
 from unittest.mock import AsyncMock, MagicMock
 
-from neva import Ok, Option, Result, from_optional
+from neva.support import Ok, Option, Result, from_optional
 from neva.support.accessors import get_attr
 
 
@@ -162,7 +162,7 @@ class FacadeMeta(ABCMeta):
 
     def restore(cls) -> None:
         """Restore the facade to its real service, removing any fake or spy."""
-        FacadeMeta._fake_instances.pop(cls, None)
+        _ = FacadeMeta._fake_instances.pop(cls, None)
 
     @contextmanager
     def faking(cls) -> Iterator[AsyncMock]:

python_neva-3.1.0/neva/arch/integrations/__init__.py

@@ -0,0 +1 @@
+"""Integrations module providing integrations with external frameworks."""

{python_neva-2.4.1/neva/arch → python_neva-3.1.0/neva/arch/integrations}/faststream.py

@@ -2,16 +2,15 @@
 
 from collections.abc import AsyncGenerator, AsyncIterator
 from contextlib import asynccontextmanager
-from typing import Any, Callable
+from typing import Any
 
-import dishka
 import faststream
 from faststream._internal.broker import BrokerUsecase
 from faststream._internal.configs import BrokerConfig
 from starlette.types import StatelessLifespan
 
-from neva import Result
 from neva.arch import Application, ServiceProvider
+from neva.support import Result
 
 
 class FastStream(faststream.FastStream):
@@ -37,28 +36,6 @@ class FastStream(faststream.FastStream):
         """
         return self.application.register(provider=provider)
 
-    def bind(
-        self,
-        source: type | Callable[..., Any],
-        *,
-        interface: type | None = None,
-        scope: dishka.BaseScope | None = None,
-    ) -> None:
-        """Binds a source to the container."""
-        self.application.bind(
-            source=source,
-            interface=interface,
-            scope=scope,
-        )
-
-    def make[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.
-        """
-        return self.application.make(interface=interface)
-
     @asynccontextmanager
     async def lifespan(self) -> AsyncGenerator[None, None]:
         """Async context manager for the application lifespan."""
@@ -69,7 +46,7 @@ class FastStream(faststream.FastStream):
         self,
     ) -> StatelessLifespan["FastStream"]:
         @asynccontextmanager
-        async def composed_lifespan(app: faststream.FastStream) -> AsyncIterator[None]:
+        async def composed_lifespan(_: faststream.FastStream) -> AsyncIterator[None]:
             async with self.lifespan():
                 yield
 

{python_neva-2.4.1 → python_neva-3.1.0}/neva/arch/service_provider.py

@@ -9,9 +9,19 @@ from __future__ import annotations
 
 import abc
 from contextlib import AbstractAsyncContextManager
-from typing import TYPE_CHECKING, Any, ClassVar, Protocol, Self, runtime_checkable
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ClassVar,
+    Protocol,
+    Self,
+    runtime_checkable,
+)
 
-from neva import Result
+import dishka
+
+from neva.support import Result
 
 
 if TYPE_CHECKING:
@@ -67,8 +77,23 @@ class ServiceProvider(abc.ABC):
             app: The application instance.
 
         """
+        self.provider: dishka.Provider = dishka.Provider(scope=dishka.Scope.APP)
         self.app = app
 
+    def bind(
+        self,
+        source: type | Callable[..., Any],
+        *,
+        interface: type | None = None,
+        scope: dishka.BaseScope | None = None,
+    ) -> None:
+        """Binds a source to the container."""
+        _ = self.provider.provide(
+            source=source,
+            scope=scope,
+            provides=interface,
+        )
+
     @abc.abstractmethod
     def register(self) -> Result[Self, str]:
         """Register services into the application container.

{python_neva-2.4.1 → python_neva-3.1.0}/neva/config/base_providers.py

@@ -11,7 +11,7 @@ from neva.events.provider import EventServiceProvider
 from neva.obs import LogServiceProvider
 
 
-def base_providers() -> set[type[ServiceProvider]]:
+def base_providers() -> list[type[ServiceProvider]]:
     """Return the list of base service providers.
 
     These providers are automatically registered during application
@@ -24,8 +24,8 @@ def base_providers() -> set[type[ServiceProvider]]:
         Set of service provider classes to register.
 
     """
-    return {
-        DatabaseServiceProvider,
-        EventServiceProvider,
+    return [
         LogServiceProvider,
-    }
+        EventServiceProvider,
+        DatabaseServiceProvider,
+    ]

{python_neva-2.4.1 → python_neva-3.1.0}/neva/config/loader.py

@@ -10,7 +10,7 @@ from pathlib import Path
 from types import ModuleType
 from typing import Any
 
-from neva import Err, Ok, Option, Result
+from neva.support import Err, Ok, Option, Result
 from neva.support.accessors import get_attr
 
 

{python_neva-2.4.1 → python_neva-3.1.0}/neva/config/repository.py

@@ -5,11 +5,11 @@ store for all application configuration values. It supports dot notation for
 nested access and can be frozen to prevent modifications after initialization.
 """
 
-from typing import Any
+from typing import Any, cast
 
 from typing_extensions import TypeForm
 
-from neva import Err, Ok, Result
+from neva.support import Err, Ok, Result
 
 
 class ConfigRepository:
@@ -65,14 +65,12 @@ class ConfigRepository:
     def get[T](
         self,
         key: str,
-        default: T | None = None,
         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.
 
         Returns:
@@ -82,18 +80,14 @@ class ConfigRepository:
         keys = key.split(".")
         current = self._items
 
-        try:
-            for k in keys:
-                if not isinstance(current, dict):
-                    if default is not None:
-                        return Ok(default)
-                    return Err(f"Config key '{key}' not found")
+        for k in keys:
+            if not isinstance(current, dict):
+                return Err(f"Config key '{key}' not found")
+            try:
                 current = current[k]
-            return Ok(current)  # type: ignore [arg-type]
-        except KeyError:
-            if default is not None:
-                return Ok(default)
-            return Err(f"Config key '{key}' not found")
+            except KeyError:
+                return Err(f"Config key '{key}' not found")
+        return Ok(cast(T, current))
 
     def has(self, key: str) -> bool:
         """Check if a configuration key exists.

{python_neva-2.4.1 → python_neva-3.1.0}/neva/database/connection.py

@@ -6,21 +6,21 @@ from contextvars import ContextVar
 from dataclasses import dataclass, field
 from typing import final
 
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+from sqlalchemy.ext import asyncio
 
-from neva import Nothing, Option, Some, from_optional
-from neva.database.transaction import BoundTransaction, Transaction, TransactionState
+from neva.database.transaction import BoundTransaction, TransactionState
 from neva.obs import LogManager
+from neva.support import Nothing, Option, Some, from_optional
 
 
 @dataclass
 class TransactionRegistry:
     """A registry of ongoing transactions."""
 
-    by_connection: dict[str, Transaction] = field(default_factory=dict)
-    stack: list[Transaction] = field(default_factory=list)
+    by_connection: dict[str, BoundTransaction] = field(default_factory=dict)
+    stack: list[BoundTransaction] = field(default_factory=list)
 
-    def extend(self, transaction: Transaction) -> "TransactionRegistry":
+    def extend(self, transaction: BoundTransaction) -> "TransactionRegistry":
         """Adds a new transaction to the registry.
 
         Returns:
@@ -45,7 +45,7 @@ class TransactionContext:
         if _tx_registry.get() is None:
             _ = _tx_registry.set(TransactionRegistry())
 
-    def current(self, connection: str | None = None) -> Option[Transaction]:
+    def current(self, connection: str | None = None) -> Option[BoundTransaction]:
         """Get the current transaction.
 
         Returns:
@@ -73,15 +73,28 @@ class ConnectionManager:
         name: str,
         tx_context: TransactionContext,
         logger: LogManager | None,
-        session_factory: async_sessionmaker[AsyncSession] | None = None,
+        engine: asyncio.AsyncEngine,
     ) -> None:
         self.name = name
         self.tx_context = tx_context
         self.logger = logger
-        self.session_factory = session_factory
+        self._engine = engine
+        self.session_factory = asyncio.async_sessionmaker(
+            bind=engine,
+            expire_on_commit=False,
+        )
+
+    @property
+    def engine(self) -> asyncio.AsyncEngine:
+        """Returns the underlying engine."""
+        return self._engine
+
+    async def dispose(self) -> None:
+        """Clear the connection manager."""
+        await self._engine.dispose()
 
     @asynccontextmanager
-    async def _scoped(self, tx: Transaction) -> AsyncIterator[None]:
+    async def _scoped(self, tx: BoundTransaction) -> AsyncIterator[None]:
         """Manage registry, state transitions, and callbacks for a transaction.
 
         Yields:
@@ -129,22 +142,6 @@ class ConnectionManager:
         finally:
             _tx_registry.reset(token)
 
-    @asynccontextmanager
-    async def transaction(self) -> AsyncIterator[Transaction]:
-        """Open a new unbound transaction (no database session).
-
-        Intended for use in unit tests where transaction lifecycle, callbacks,
-        and context isolation need to be exercised without a real database.
-
-        Yields:
-            Transaction: An unbound transaction with no associated session.
-        """
-        parent = self.tx_context.current(self.name)
-        tx = Transaction(self.name)
-        tx.parent = parent
-        async with self._scoped(tx):
-            yield tx
-
     @asynccontextmanager
     async def begin(self) -> AsyncIterator[BoundTransaction]:
         """Open a new bound transaction with an active database session.
@@ -154,31 +151,18 @@ class ConnectionManager:
 
         Yields:
             BoundTransaction: A transaction with a guaranteed non-null session.
-
-        Raises:
-            RuntimeError: If no engine has been registered for this connection.
         """
-        if self.session_factory is None:
-            raise RuntimeError(
-                f"No engine registered for connection '{self.name}'. "
-                + "Call register_engine() before calling begin()."
-            )
-
         parent = self.tx_context.current(self.name)
 
         match parent:
-            case Some(parent_tx) if (
-                isinstance(parent_tx, BoundTransaction)
-                and parent_tx.is_accessible_from_current_task
-            ):
-                tx = Transaction(self.name)
-                tx.parent = parent
-                bound = tx.begin(parent_tx.session)
+            case Some(parent_tx) if parent_tx.is_accessible_from_current_task:
+                tx = BoundTransaction(self.name, parent_tx.session)
                 sp = await parent_tx.session.begin_nested()
+                tx.parent = parent
                 try:
-                    async with self._scoped(bound):
-                        yield bound
-                    if bound.rollback_requested:
+                    async with self._scoped(tx):
+                        yield tx
+                    if tx.rollback_requested:
                         await sp.rollback()
                     else:
                         await sp.commit()
@@ -186,14 +170,12 @@ class ConnectionManager:
                     await sp.rollback()
                     raise
             case _:
-                tx = Transaction(self.name)
-                tx.parent = Nothing()
                 async with self.session_factory() as session:
-                    bound = tx.begin(session)
+                    tx = BoundTransaction(self.name, session)
                     try:
-                        async with self._scoped(bound):
-                            yield bound
-                        if bound.rollback_requested:
+                        async with self._scoped(tx):
+                            yield tx
+                        if tx.rollback_requested:
                             await session.rollback()
                         else:
                             await session.commit()