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

{python_neva-2.4.0 → python_neva-3.0.0}/.pre-commit-config.yaml

@@ -26,3 +26,20 @@ repos:
     rev: v1.19.1
     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-2.4.0 → python_neva-3.0.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: python-neva
-Version: 2.4.0
+Version: 3.0.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

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

@@ -4,9 +4,9 @@ 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.integrations.fastapi import App
 from neva.arch.service_provider import (
     Bootable,
     ServiceProvider,

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

@@ -1,13 +1,14 @@
 """Base application for DI and facade injection."""
 
 import os
-from collections.abc import AsyncIterator, Iterator
-from contextlib import AsyncExitStack, asynccontextmanager, contextmanager
+from collections.abc import AsyncIterator
+from contextlib import AsyncExitStack, asynccontextmanager
 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
@@ -33,7 +34,7 @@ class Application:
 
         self.config: ConfigRepository = ConfigRepository()
         self.providers: dict[type, ServiceProvider] = {}
-        self.di_provider: dishka.Provider = dishka.Provider(scope=dishka.Scope.APP)
+        self.root_provider: dishka.Provider = dishka.Provider(scope=dishka.Scope.APP)
 
         configuration_path = (
             config_path
@@ -50,7 +51,9 @@ 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]]
@@ -61,14 +64,18 @@ class Application:
         providers: set[type[ServiceProvider]] = set(providers_from_file).union(
             set(providers_from_app)
         )
+        _ = self.root_provider.provide(source=lambda: self, provides=Application)
         self.register_providers(base_providers().union(providers))
-        self.bind(source=lambda: self, interface=Application)
         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.
@@ -90,6 +97,7 @@ class Application:
         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,32 +106,43 @@ 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[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.
         """
         try:
-            return Ok(self.container.get(interface))
+            return Ok(await self.container.get(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]:
+    def make_sync[T](self, interface: type[T]) -> Result[T, str]:
+        """Synchronous version of make.
+
+        Returns:
+            Result containing the resolved type instance or an error message.
+        """
+        try:
+            return Ok(self.container.get_sync(interface))
+        except Exception as e:
+            return Err(f"Failed to resolve service '{interface.__name__}': {e}")
+
+    @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:
+        async with self.container(scope=scope) as container:
             self.container = container
             try:
                 yield self
@@ -140,9 +159,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 +172,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(EventDispatcher)
         if result.is_err:
             return
 

{python_neva-2.4.0 → python_neva-3.0.0}/neva/arch/facade.py

@@ -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(cls.get_facade_accessor()))
+            .and_then(lambda a: a.make_sync(cls.get_facade_accessor()))
             .unwrap()
         )
         spy_obj = MagicMock(spec=type(real), wraps=real)
@@ -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]:
@@ -198,7 +198,7 @@ class FacadeMeta(ABCMeta):
         """
         if cls in FacadeMeta._fake_instances:
             return Ok(cast(T, FacadeMeta._fake_instances[cls]))
-        return app.make(interface)
+        return app.make_sync(interface)
 
 
 class Facade(ABC, metaclass=FacadeMeta):

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

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

python_neva-2.4.0/neva/arch/app.py → python_neva-3.0.0/neva/arch/integrations/fastapi.py

@@ -8,11 +8,10 @@ the Application class.
 from collections.abc import AsyncGenerator, AsyncIterator, Sequence
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import Any, Callable
 
-import dishka
 import fastapi
-from dishka.integrations.fastapi import setup_dishka
+from dishka import FromDishka
+from dishka.integrations.fastapi import FastapiProvider, setup_dishka
 from starlette.middleware import Middleware
 from starlette.routing import BaseRoute
 from starlette.types import StatefulLifespan, StatelessLifespan
@@ -44,6 +43,7 @@ class App(fastapi.FastAPI):
 
         """
         self.application: Application = Application(config_path=config_path)
+        self.application.build_container(FastapiProvider())
 
         self._lifespan: StatelessLifespan["App"] | StatefulLifespan["App"] | None = (
             lifespan
@@ -51,13 +51,15 @@ class App(fastapi.FastAPI):
         config = self.application.config
 
         super().__init__(
-            debug=config.get("app.debug", default=False).unwrap(),
+            debug=config.get("app.debug", type_=bool).unwrap_or(False),  # noqa: FBT003
             routes=routes,
-            title=config.get("app.title", default="Neva Application").unwrap(),
-            version=config.get("app.version", default="0.1.0").unwrap(),
-            openapi_url=config.get("app.openapi_url", default="/openapi.json").unwrap(),
-            docs_url=config.get("app.docs_url", default="/docs").unwrap(),
-            redoc_url=config.get("app.redoc_url", default="/redoc").unwrap(),
+            title=config.get("app.title", type_=str).unwrap_or("Neva Application"),
+            version=config.get("app.version", type_=str).unwrap_or("0.1.0"),
+            openapi_url=config.get("app.openapi_url", type_=str).unwrap_or(
+                "/openapi.json"
+            ),
+            docs_url=config.get("app.docs_url", type_=str).unwrap_or("/docs"),
+            redoc_url=config.get("app.redoc_url", type_=str).unwrap_or("/redoc"),
             lifespan=self._create_lifespan(),
             middleware=middlewares,
         )
@@ -75,28 +77,6 @@ class App(fastapi.FastAPI):
         """
         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]:
         """Manage the lifecycle of the application."""
@@ -127,3 +107,6 @@ class App(fastapi.FastAPI):
                     yield
 
         return composed_lifespan
+
+
+Inject = FromDishka

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

@@ -2,9 +2,8 @@
 
 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
@@ -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.0 → python_neva-3.0.0}/neva/arch/service_provider.py

@@ -9,7 +9,17 @@ 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,
+)
+
+import dishka
 
 from neva import Result
 
@@ -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.0 → python_neva-3.0.0}/neva/config/repository.py

@@ -5,7 +5,9 @@ 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
 
@@ -63,14 +65,12 @@ class ConfigRepository:
     def get[T](
         self,
         key: str,
-        default: T | None = None,
-        type_: type[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:
@@ -80,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.0 → python_neva-3.0.0}/neva/database/provider.py

@@ -8,6 +8,7 @@ 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
@@ -18,22 +19,21 @@ class DatabaseServiceProvider(ServiceProvider):
 
     @override
     def register(self) -> Result[Self, str]:
-        self.app.bind(TransactionContext)
-        self.app.bind(DatabaseManager)
+        self.bind(TransactionContext)
+        self.bind(DatabaseManager)
         return Ok(self)
 
     @asynccontextmanager
     async def lifespan(self) -> AsyncIterator[None]:
         """Initialize and cleanup database connections."""
-        logger: LogManager = self.app.make(LogManager).unwrap()
-        db: DatabaseManager = self.app.make(DatabaseManager).unwrap()
+        logger: LogManager = (await self.app.make(LogManager)).unwrap()
+        db: DatabaseManager = (await self.app.make(DatabaseManager)).unwrap()
         logger.info("Beginning SQLAlchemy initialization...")
-        match self.app.config.get("database"):
+        match self.app.config.get("database", type_=DatabaseConfig):
             case Ok(config):
-                connections: dict = config.get("connections", {})
+                connections: dict[str, ConnectionConfig] = config["connections"]
                 for name, conn_config in connections.items():
-                    url = conn_config.pop("url")
-                    engine = create_async_engine(url, **conn_config)
+                    engine = create_async_engine(**conn_config)
                     db.register_engine(name, engine)
                     logger.info(f"Registered engine for connection '{name}'.")
                 logger.info("SQLAlchemy initialization complete.")

{python_neva-2.4.0 → python_neva-3.0.0}/neva/events/dispatcher.py

@@ -72,7 +72,7 @@ class EventDispatcher:
         Returns:
             EventListener[Any]: The resolved listener.
         """
-        result = self._app.make(listener_cls)
+        result = self._app.make_sync(listener_cls)
         if result.is_ok:
             return result.unwrap()
         return listener_cls()

{python_neva-2.4.0 → python_neva-3.0.0}/neva/events/provider.py

@@ -23,5 +23,5 @@ class EventServiceProvider(ServiceProvider):
         """
         from neva.events.dispatcher import EventDispatcher
 
-        self.app.bind(EventDispatcher)
+        self.bind(EventDispatcher)
         return Ok(self)

{python_neva-2.4.0 → python_neva-3.0.0}/neva/obs/logging/provider.py

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

{python_neva-2.4.0 → python_neva-3.0.0}/neva/security/encryption/encrypter.py

@@ -127,7 +127,7 @@ class AesEncrypter:
             ValueError: If no encryption key is configured.
         """
         previous_keys = self._app.config.get(
-            "app.previous_keys", default=[], type_=list[str]
+            "app.previous_keys", type_=list[str]
         ).unwrap_or([])
 
         match self._app.config.get("app.key", type_=str):

{python_neva-2.4.0 → python_neva-3.0.0}/neva/security/hashing/hash_manager.py

@@ -1,6 +1,6 @@
 """Hash manager for managing password hashing strategies."""
 
-from typing import Literal, cast, override
+from typing import override
 
 from neva import Option
 from neva.arch import Application
@@ -108,15 +108,15 @@ class HashManager(StrategyResolver[Hasher]):
             Configured Argon2Hasher instance.
         """
         argon_config = manager.app.config.get(
-            "hashing.argon", default={}, type_=Argon2Config
+            "hashing.argon", type_=Argon2Config
         ).unwrap()
 
         return Argon2Hasher(
-            time_cost=cast(int, argon_config.get("time_cost", 2)),
-            memory_cost=cast(int, argon_config.get("memory_cost", 102400)),
-            parallelism=cast(int, argon_config.get("parallelism", 8)),
-            hash_len=cast(int, argon_config.get("hash_len", 16)),
-            salt_len=cast(int, argon_config.get("salt_len", 16)),
+            time_cost=argon_config.get("time_cost", 2),
+            memory_cost=argon_config.get("memory_cost", 102400),
+            parallelism=argon_config.get("parallelism", 8),
+            hash_len=argon_config.get("hash_len", 16),
+            salt_len=argon_config.get("salt_len", 16),
         )
 
     def _create_bcrypt_hasher(self, manager: StrategyResolver[Hasher]) -> BcryptHasher:
@@ -129,10 +129,10 @@ class HashManager(StrategyResolver[Hasher]):
             Configured BcryptHasher instance.
         """
         bcrypt_config = manager.app.config.get(
-            "hashing.bcrypt", default={}, type_=BcryptConfig
+            "hashing.bcrypt", type_=BcryptConfig
         ).unwrap()
 
         return BcryptHasher(
-            rounds=cast(int, bcrypt_config.get("rounds", 12)),
-            prefix=cast(Literal["2a", "2b"], bcrypt_config.get("prefix", "2b")),
+            rounds=bcrypt_config.get("rounds", 12),
+            prefix=bcrypt_config.get("prefix", "2b"),
         )

{python_neva-2.4.0 → python_neva-3.0.0}/neva/security/provider.py

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

{python_neva-2.4.0 → python_neva-3.0.0}/neva/testing/test_case.py

@@ -95,7 +95,7 @@ class RefreshDatabase:
         _setup_database_engine: None,  # ordering dependency: runs after engine setup
     ) -> AsyncIterator[None]:
         """Wrap the test in a DB transaction and roll it back on completion."""
-        db = _test_case_application.make(DatabaseManager).unwrap()
+        db = (await _test_case_application.make(DatabaseManager)).unwrap()
         async with db.begin() as tx:
             tx.share()
             yield

{python_neva-2.4.0 → python_neva-3.0.0}/pyproject.toml

@@ -7,13 +7,13 @@ packages = ["neva"]
 
 [project]
 name = "python-neva"
-version = "2.4.0"
+version = "3.0.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
   "cryptography>=46.0.3",
-  "dishka>=1.7.2",
+  "dishka>=1.10.0",
   "fastapi[all]>=0.129.0",
   "faststream>=0.6.6",
   "pwdlib[argon2,bcrypt]>=0.3.0",
@@ -43,6 +43,13 @@ dev = [
   "ruff>=0.15.6",
 ]
 
+[tool.basedpyright]
+enableExperimentalFeatures = true
+
+[tool.mypy]
+enable_incomplete_feature = ["TypeForm"]
+plugins = ["pydantic.mypy"]
+
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"