python-neva 3.0.0__tar.gz → 3.1.1__tar.gz

python_neva-3.1.1/CHANGELOG.md

@@ -0,0 +1,48 @@
+## 3.1.1 (2026-05-11)
+
+### 📌➕⬇️➖⬆️ Dependencies
+
+- bump opt dep on neva-fastapi
+
+## 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-3.0.0 → python_neva-3.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-neva
-Version: 3.0.0
+Version: 3.1.1
 Summary: Add your description here
 Requires-Python: >=3.12
 Requires-Dist: aiosqlite>=0.20.0
@@ -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>=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'

{python_neva-3.0.0 → python_neva-3.1.1}/neva/arch/__init__.py

@@ -6,7 +6,6 @@ and facade implementations.
 
 from neva.arch.application import Application
 from neva.arch.facade import Facade
-from neva.arch.integrations.fastapi import App
 from neva.arch.service_provider import (
     Bootable,
     ServiceProvider,
@@ -14,7 +13,6 @@ from neva.arch.service_provider import (
 
 
 __all__ = [
-    "App",
     "Application",
     "Bootable",
     "Facade",

{python_neva-3.0.0 → python_neva-3.1.1}/neva/arch/application.py

@@ -1,8 +1,10 @@
 """Base application for DI and facade injection."""
 
 import os
-from collections.abc import AsyncIterator
+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
 
@@ -10,10 +12,15 @@ import dishka
 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:
@@ -33,7 +40,7 @@ class Application:
         from neva.config.repository import ConfigRepository
 
         self.config: ConfigRepository = ConfigRepository()
-        self.providers: dict[type, ServiceProvider] = {}
+        self.providers: OrderedDict[type, ServiceProvider] = OrderedDict()
         self.root_provider: dishka.Provider = dishka.Provider(scope=dishka.Scope.APP)
 
         configuration_path = (
@@ -55,17 +62,19 @@ class Application:
                     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([])
+        )
+        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(base_providers().union(providers))
+        self.register_providers(providers)
         self._bind_event_listeners()
         self.build_container(self.root_provider)
 
@@ -92,7 +101,7 @@ 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)
@@ -112,25 +121,27 @@ class Application:
             provides=interface,
         )
 
-    async 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 self.container.get(interface))
+            return Ok(await container.get(interface))
         except Exception as e:
             return Err(f"Failed to resolve service '{interface.__name__}': {e}")
 
-    def make_sync[T](self, interface: type[T]) -> Result[T, str]:
+    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_sync(interface))
+            return Ok(container.get_sync(interface))
         except Exception as e:
             return Err(f"Failed to resolve service '{interface.__name__}': {e}")
 
@@ -141,13 +152,13 @@ class Application:
         Yields:
             The application instance with the new scope.
         """
-        parent = self.container
-        async 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]:
@@ -176,7 +187,7 @@ class Application:
         """Wire event-listener mappings from all providers onto the dispatcher."""
         from neva.events.dispatcher import EventDispatcher
 
-        result = await self.make(EventDispatcher)
+        result = await self.make_async(EventDispatcher)
         if result.is_err:
             return
 

{python_neva-3.0.0 → python_neva-3.1.1}/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
 
 
@@ -153,7 +153,7 @@ class FacadeMeta(ABCMeta):
         real: object = (
             cls._get_app()
             .ok_or(f"Cannot spy on {cls.__name__}: no application set.")
-            .and_then(lambda a: a.make_sync(cls.get_facade_accessor()))
+            .and_then(lambda a: a.make(cls.get_facade_accessor()))
             .unwrap()
         )
         spy_obj = MagicMock(spec=type(real), wraps=real)
@@ -198,7 +198,7 @@ class FacadeMeta(ABCMeta):
         """
         if cls in FacadeMeta._fake_instances:
             return Ok(cast(T, FacadeMeta._fake_instances[cls]))
-        return app.make_sync(interface)
+        return app.make(interface)
 
 
 class Facade(ABC, metaclass=FacadeMeta):

{python_neva-3.0.0 → python_neva-3.1.1}/neva/arch/integrations/faststream.py

@@ -9,8 +9,8 @@ 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):

{python_neva-3.0.0 → python_neva-3.1.1}/neva/arch/service_provider.py

@@ -21,7 +21,7 @@ from typing import (
 
 import dishka
 
-from neva import Result
+from neva.support import Result
 
 
 if TYPE_CHECKING:

{python_neva-3.0.0 → python_neva-3.1.1}/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-3.0.0 → python_neva-3.1.1}/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-3.0.0 → python_neva-3.1.1}/neva/config/repository.py

@@ -9,7 +9,7 @@ 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:

{python_neva-3.0.0 → python_neva-3.1.1}/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()

{python_neva-3.0.0 → python_neva-3.1.1}/neva/database/manager.py

@@ -4,13 +4,15 @@ from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from typing import final
 
-from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker
+from sqlalchemy.ext import asyncio
+from typing_extensions import deprecated
 
-from neva import Nothing, Option, Some
+from neva.database.config import ConnectionConfig
 from neva.database.connection import ConnectionManager, TransactionContext
-from neva.database.transaction import BoundTransaction, Transaction
+from neva.database.transaction import BoundTransaction
 from neva.obs import LogManager
 from neva.obs.instrumentation.sqlalchemy import instrument
+from neva.support import Nothing, Option, Some, from_optional
 
 
 @final
@@ -21,10 +23,9 @@ class DatabaseManager:
         self._tx_context = tx_context
         self._logger = logger
         self._connections: dict[str, ConnectionManager] = {}
-        self._engines: dict[str, AsyncEngine] = {}
-        self._session_factories: dict[str, async_sessionmaker[AsyncSession]] = {}
 
-    def register_engine(self, name: str, engine: AsyncEngine) -> None:
+    @deprecated("Please use DatabaseManager.register_connection instead.")
+    def register_engine(self, name: str, engine: asyncio.AsyncEngine) -> None:
         """Register an engine and create a session factory for a connection.
 
         Args:
@@ -32,26 +33,34 @@ class DatabaseManager:
             engine: The async engine.
         """
         instrument(engine)
-        self._engines[name] = engine
-        self._session_factories[name] = async_sessionmaker(
-            bind=engine,
-            expire_on_commit=False,
+        self._connections[name] = ConnectionManager(
+            name,
+            self._tx_context,
+            self._logger,
+            engine,
         )
-        _ = self._connections.pop(name, None)
 
-    def connection(self, name: str) -> ConnectionManager:
-        """Returns a connection manager for the given name."""
-        return self._connections.setdefault(
+    def register_connection(self, name: str, config: ConnectionConfig) -> None:
+        """Register a connection. This initializes the engine and session factory.
+
+        Args:
+            name: The connection name.
+            config: The connection configuration.
+
+        """
+        engine = asyncio.create_async_engine(**config)
+        self._connections[name] = ConnectionManager(
             name,
-            ConnectionManager(
-                name,
-                self._tx_context,
-                self._logger,
-                self._session_factories.get(name),
-            ),
+            self._tx_context,
+            self._logger,
+            engine,
         )
 
-    def current(self, connection: str | None = None) -> Option[Transaction]:
+    def connection(self, name: str) -> Option[ConnectionManager]:
+        """Returns a connection manager for the given name."""
+        return from_optional(self._connections.get(name))
+
+    def current(self, connection: str | None = None) -> Option[BoundTransaction]:
         """Returns the current transaction.
 
         If no connection is specified, this will return the most recent transaction on
@@ -59,7 +68,7 @@ class DatabaseManager:
         """
         return self._tx_context.current(connection)
 
-    def session(self, connection: str | None = None) -> Option[AsyncSession]:
+    def session(self, connection: str | None = None) -> Option[asyncio.AsyncSession]:
         """Returns the current session for a connection.
 
         Only returns a session if the active transaction was opened by the
@@ -77,26 +86,11 @@ class DatabaseManager:
             transaction was opened by a different asyncio task.
         """
         match self.current(connection):
-            case Some(tx) if (
-                isinstance(tx, BoundTransaction) and tx.is_accessible_from_current_task
-            ):
+            case Some(tx) if tx.is_accessible_from_current_task:
                 return Some(tx.session)
             case _:
                 return Nothing()
 
-    @asynccontextmanager
-    async def transaction(self, name: str = "default") -> AsyncIterator[Transaction]:
-        """Open an unbound transaction on the named connection.
-
-        Intended for unit tests that exercise transaction lifecycle and callbacks
-        without a real database engine.
-
-        Yields:
-            Transaction: An unbound transaction with no associated session.
-        """
-        async with self.connection(name).transaction() as tx:
-            yield tx
-
     @asynccontextmanager
     async def begin(self, name: str = "default") -> AsyncIterator[BoundTransaction]:
         """Open a bound transaction on the named connection.
@@ -109,14 +103,16 @@ class DatabaseManager:
 
         Raises:
             RuntimeError: If no engine has been registered for the connection.
-        """  # noqa: DOC502 explicit documentation of the possible exception raised by 'begin'
-        async with self.connection(name).begin() as tx:
-            yield tx
+        """
+        match self.connection(name):
+            case Nothing():
+                raise RuntimeError(f"No connection registered with name {name}")
+            case Some(conn):
+                async with conn.begin() as tx:
+                    yield tx
 
     async def close(self) -> None:
         """Dispose all engines and clear caches."""
-        for engine in self._engines.values():
-            await engine.dispose()
-        self._engines.clear()
-        self._session_factories.clear()
+        for conn in self._connections.values():
+            await conn.dispose()
         self._connections.clear()

{python_neva-3.0.0 → python_neva-3.1.1}/neva/database/provider.py

@@ -4,14 +4,12 @@ from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from typing import Self, override
 
-from sqlalchemy.ext.asyncio import create_async_engine
-
-from neva import Err, Ok, Result
 from neva.arch import ServiceProvider
 from neva.database.config import ConnectionConfig, DatabaseConfig
 from neva.database.connection import TransactionContext
 from neva.database.manager import DatabaseManager
 from neva.obs import LogManager
+from neva.support import Err, Ok, Result
 
 
 class DatabaseServiceProvider(ServiceProvider):
@@ -26,15 +24,14 @@ class DatabaseServiceProvider(ServiceProvider):
     @asynccontextmanager
     async def lifespan(self) -> AsyncIterator[None]:
         """Initialize and cleanup database connections."""
-        logger: LogManager = (await self.app.make(LogManager)).unwrap()
-        db: DatabaseManager = (await self.app.make(DatabaseManager)).unwrap()
+        logger: LogManager = (await self.app.make_async(LogManager)).unwrap()
+        db: DatabaseManager = (await self.app.make_async(DatabaseManager)).unwrap()
         logger.info("Beginning SQLAlchemy initialization...")
         match self.app.config.get("database", type_=DatabaseConfig):
             case Ok(config):
                 connections: dict[str, ConnectionConfig] = config["connections"]
                 for name, conn_config in connections.items():
-                    engine = create_async_engine(**conn_config)
-                    db.register_engine(name, engine)
+                    db.register_connection(name, conn_config)
                     logger.info(f"Registered engine for connection '{name}'.")
                 logger.info("SQLAlchemy initialization complete.")
                 yield