python-neva 0.4.0__tar.gz → 0.6.0.dev1__tar.gz

{python_neva-0.4.0 → python_neva-0.6.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-neva
-Version: 0.4.0
+Version: 0.6.0.dev1
 Summary: Add your description here
 Requires-Python: >=3.12
 Requires-Dist: cryptography>=46.0.3
@@ -11,6 +11,7 @@ Requires-Dist: pwdlib[argon2,bcrypt]>=0.3.0
 Requires-Dist: pyinstrument>=5.1.1
 Requires-Dist: structlog>=25.5.0
 Requires-Dist: tortoise-orm[accel]>=0.25.3
+Requires-Dist: typer>=0.21.1
 Provides-Extra: testing
 Requires-Dist: pytest-asyncio>=0.25.3; extra == 'testing'
 Requires-Dist: pytest>=9.0.2; extra == 'testing'

{python_neva-0.4.0 → python_neva-0.6.0.dev1}/neva/arch/application.py

@@ -1,9 +1,10 @@
 """Base application for DI and facade injection."""
 
-from collections.abc import AsyncIterator
-from contextlib import AsyncExitStack, asynccontextmanager
+from collections.abc import AsyncIterator, Iterator
+from contextlib import AsyncExitStack, asynccontextmanager, contextmanager
+import os
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any, Callable, Self
 
 import dishka
 from dishka.integrations.fastapi import FastapiProvider
@@ -33,9 +34,10 @@ class Application:
         self.providers: dict[type, ServiceProvider] = {}
         self.di_provider: dishka.Provider = dishka.Provider(scope=dishka.Scope.APP)
 
+        configuration_path = config_path or os.getenv("NEVA_CONFIG_PATH", default=None)
         config_provider = ConfigServiceProvider(
             app=self,
-            config_path=config_path,
+            config_path=configuration_path,
         ).register()
         if config_provider.is_err:
             raise RuntimeError(
@@ -114,6 +116,21 @@ class Application:
         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]:
+        """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
+            try:
+                yield self
+            finally:
+                self.container = parent
+
     @asynccontextmanager
     async def lifespan(self) -> AsyncIterator[None]:
         """Wire the facades and providers."""

python_neva-0.6.0.dev1/neva/console/__init__.py

@@ -0,0 +1 @@
+"""CLI utilities."""

python_neva-0.6.0.dev1/neva/console/kernel.py

@@ -0,0 +1,47 @@
+"""Defines the CLI kernel."""
+
+import asyncio
+from functools import wraps
+from typing import Any, Callable, override
+from typer import Typer
+from typer.core import click
+
+from typer.models import CommandFunctionType
+
+from neva.arch import Application
+
+
+class Kernel(Typer):
+    """CLI kernel."""
+
+    def __init__(
+        self,
+        callback: Callable[..., Any] | None = None,
+    ) -> None:
+        """Initialize the CLI kernel."""
+        super().__init__(callback=callback)
+
+    @override
+    def command(
+        self,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Callable[[CommandFunctionType], CommandFunctionType]:
+        base_decorator = super().command(*args, **kwargs)
+
+        def decorator(f: CommandFunctionType) -> CommandFunctionType:
+            @wraps(f)
+            def wrapper(*f_args: Any, **f_kwargs: Any) -> Any:  # noqa: ANN401
+                ctx = click.get_current_context()
+                config_path = ctx.obj.get("config_path", None)
+                app = Application(config_path)
+
+                async def runner() -> Any:  # noqa: ANN401
+                    async with app.lifespan():
+                        return f(*f_args, **f_kwargs)
+
+                return asyncio.run(runner())
+
+            return base_decorator(wrapper)
+
+        return decorator

python_neva-0.6.0.dev1/neva/console/runner.py

@@ -0,0 +1,26 @@
+"""CLI runner."""
+
+from typing import Annotated
+
+import typer
+
+from neva.console.kernel import Kernel
+
+
+def set_config(
+    ctx: typer.Context,
+    config_path: Annotated[
+        str,
+        typer.Option(help="Sets the config path"),
+    ] = "",
+) -> None:
+    """Set the configuration path."""
+    ctx.obj = {"config_path": config_path}
+
+
+app = Kernel(set_config)
+
+
+def main() -> None:
+    """Run the CLI."""
+    app()

{python_neva-0.4.0 → python_neva-0.6.0.dev1}/neva/security/hashing/config.py

@@ -6,23 +6,23 @@ from typing import Literal, NotRequired, TypedDict
 class BcryptConfig(TypedDict):
     """Bcrypt hasher config."""
 
-    rounds: int
-    prefix: str
+    rounds: NotRequired[int]
+    prefix: NotRequired[Literal["2a", "2b"]]
 
 
 class Argon2Config(TypedDict):
     """Argon2 hasher config."""
 
-    time_cost: int
-    memory_cost: int
-    parallelism: int
-    hash_len: int
-    salt_len: int
+    time_cost: NotRequired[int]
+    memory_cost: NotRequired[int]
+    parallelism: NotRequired[int]
+    hash_len: NotRequired[int]
+    salt_len: NotRequired[int]
 
 
 class HashingConfig(TypedDict):
     """Hasher config."""
 
-    driver: Literal["argon2", "bcrypt"]
+    driver: Literal["argon2", "bcrypt", "sha256"]
     argon: NotRequired[Argon2Config]
     bcrypt: NotRequired[BcryptConfig]

{python_neva-0.4.0 → python_neva-0.6.0.dev1}/neva/security/hashing/hash_manager.py

@@ -8,6 +8,7 @@ from neva.config import ConfigRepository
 from neva.security.hashing.hashers.argon2 import Argon2Hasher
 from neva.security.hashing.hashers.bcrypt import BcryptHasher
 from neva.security.hashing.hashers.protocol import Hasher
+from neva.security.hashing.hashers.sha256 import Sha256Hasher
 from neva.support.strategy import StrategyResolver
 
 
@@ -22,15 +23,16 @@ class HashManager(StrategyResolver[Hasher]):
         """
         super().__init__(app)
 
-        self.register("argon2", self._create_argon2_hasher)
-        self.register("bcrypt", self._create_bcrypt_hasher)
+        _ = self.register("argon2", self._create_argon2_hasher)
+        _ = self.register("bcrypt", self._create_bcrypt_hasher)
+        _ = self.register("sha256", self._create_sha256_hasher)
 
     @override
     def default(self) -> Option[str]:
         """Get the default hasher from configuration.
 
         Returns:
-            Option containing the default hasher name ("argon2" or "bcrypt").
+            Option containing the default hasher name.
         """
         config_result = self.app.make(ConfigRepository)
         if config_result.is_err:
@@ -144,3 +146,11 @@ class HashManager(StrategyResolver[Hasher]):
                 prefix=bcrypt_config.get("prefix", "2b"),
             )
         return BcryptHasher()
+
+    def _create_sha256_hasher(self, _: StrategyResolver[Hasher]) -> Sha256Hasher:
+        """Create an instance of the SHA256 hash strategy.
+
+        Returns:
+            Configured Sha256Hasher instance.
+        """
+        return Sha256Hasher()

python_neva-0.6.0.dev1/neva/security/hashing/hashers/sha256.py

@@ -0,0 +1,42 @@
+"""SHA256 hasher."""
+
+import hashlib
+from typing import override
+from neva.security.hashing.hashers.protocol import Hasher
+
+
+def ensure_bytes(value: str | bytes) -> bytes:
+    """Ensure the value is in bytes.
+
+    Returns:
+        the value in bytes
+    """
+    return value.encode() if isinstance(value, str) else value
+
+
+class Sha256Hasher(Hasher):
+    """SHA256 hasher."""
+
+    @override
+    def make(
+        self,
+        plaintext: str | bytes,
+        *,
+        salt: bytes | None = None,
+    ) -> str:
+        return hashlib.sha256(ensure_bytes(plaintext)).hexdigest()
+
+    @override
+    def check(
+        self,
+        plaintext: str | bytes,
+        hashed: str | bytes,
+    ) -> bool:
+        return hashlib.sha256(ensure_bytes(plaintext)).digest() == ensure_bytes(hashed)
+
+    @override
+    def needs_rehash(
+        self,
+        hashed: str | bytes,
+    ) -> bool:
+        return False

{python_neva-0.4.0 → python_neva-0.6.0.dev1}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["neva"]
 
 [project]
 name = "python-neva"
-version = "0.4.0"
+version = "0.6.0.dev1"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -20,11 +20,15 @@ dependencies = [
   "pyinstrument>=5.1.1",
   "structlog>=25.5.0",
   "tortoise-orm[accel]>=0.25.3",
+  "typer>=0.21.1",
 ]
 
 [project.optional-dependencies]
 testing = ["pytest>=9.0.2", "pytest-asyncio>=0.25.3"]
 
+[project.scripts]
+neva = "neva.console.runner:main"
+
 [dependency-groups]
 dev = [
   "bandit>=1.9.2",

python_neva-0.6.0.dev1/tests/test_scope.py

@@ -0,0 +1,144 @@
+from pathlib import Path
+from typing import Self, override
+
+import dishka
+
+from neva import Ok, Result, arch
+from neva.config import ConfigRepository
+from neva.testing import TestCase
+
+
+class RequestService:
+    """A service scoped to REQUEST."""
+
+    def __init__(self) -> None:
+        self.value = id(self)
+
+
+class RequestScopedProvider(arch.ServiceProvider):
+    """Registers a REQUEST-scoped service."""
+
+    @override
+    def register(self) -> Result[Self, str]:
+        self.app.bind(
+            RequestService,
+            interface=RequestService,
+            scope=dishka.Scope.REQUEST,
+        )
+        return Ok(self)
+
+
+def _make_config_dir(tmp_path: Path) -> Path:
+    config_dir = tmp_path / "config"
+    config_dir.mkdir()
+
+    _ = (config_dir / "app.py").write_text(
+        'config = {"name": "TestApp", "debug": True}'
+    )
+    _ = (config_dir / "providers.py").write_text(
+        """
+from tests.test_scope import RequestScopedProvider
+
+config = {"providers": [RequestScopedProvider]}
+"""
+    )
+
+    return config_dir
+
+
+class TestScopeEntersChildScope(TestCase):
+    @override
+    def create_config(self, tmp_path: Path) -> Path:
+        return _make_config_dir(tmp_path)
+
+    async def test_request_scoped_service_resolved_in_scope(self) -> None:
+        with self.app.scope(dishka.Scope.REQUEST) as scoped:
+            result = scoped.make(RequestService)
+
+            assert result.is_ok
+
+    async def test_request_scoped_service_not_resolved_at_app_scope(self) -> None:
+        result = self.app.make(RequestService)
+
+        assert result.is_err
+
+    async def test_app_scoped_service_available_in_child_scope(self) -> None:
+        with self.app.scope(dishka.Scope.REQUEST) as scoped:
+            result = scoped.make(ConfigRepository)
+
+            assert result.is_ok
+
+
+class TestScopeRestoresContainer(TestCase):
+    @override
+    def create_config(self, tmp_path: Path) -> Path:
+        return _make_config_dir(tmp_path)
+
+    async def test_container_restored_after_scope_exit(self) -> None:
+        original_container = self.app.container
+
+        with self.app.scope(dishka.Scope.REQUEST):
+            assert self.app.container is not original_container
+
+        assert self.app.container is original_container
+
+    async def test_container_restored_after_exception(self) -> None:
+        original_container = self.app.container
+
+        try:
+            with self.app.scope(dishka.Scope.REQUEST):
+                msg = "intentional"
+                raise RuntimeError(msg)
+        except RuntimeError:
+            pass
+
+        assert self.app.container is original_container
+
+
+class TestScopeInstanceLifetime(TestCase):
+    @override
+    def create_config(self, tmp_path: Path) -> Path:
+        return _make_config_dir(tmp_path)
+
+    async def test_same_instance_within_scope(self) -> None:
+        with self.app.scope(dishka.Scope.REQUEST) as scoped:
+            first = scoped.make(RequestService).unwrap()
+            second = scoped.make(RequestService).unwrap()
+
+            assert first is second
+
+    async def test_different_instances_across_scopes(self) -> None:
+        with self.app.scope(dishka.Scope.REQUEST) as scoped:
+            first = scoped.make(RequestService).unwrap()
+
+        with self.app.scope(dishka.Scope.REQUEST) as scoped:
+            second = scoped.make(RequestService).unwrap()
+
+        assert first is not second
+
+
+class TestScopeDefaultTarget(TestCase):
+    @override
+    def create_config(self, tmp_path: Path) -> Path:
+        return _make_config_dir(tmp_path)
+
+    async def test_scope_without_argument_enters_next_non_skipped(self) -> None:
+        with self.app.scope() as scoped:
+            result = scoped.make(RequestService)
+
+            assert result.is_ok
+
+
+class TestNestedScopes(TestCase):
+    @override
+    def create_config(self, tmp_path: Path) -> Path:
+        return _make_config_dir(tmp_path)
+
+    async def test_nested_scope_restores_to_parent_scope(self) -> None:
+        with self.app.scope(dishka.Scope.REQUEST) as request_scoped:
+            request_container = request_scoped.container
+
+            with request_scoped.scope(dishka.Scope.ACTION) as action_scoped:
+                assert action_scoped.container is not request_container
+
+            assert request_scoped.container is request_container

{python_neva-0.4.0 → python_neva-0.6.0.dev1}/uv.lock

@@ -1267,7 +1267,7 @@ wheels = [
 
 [[package]]
 name = "python-neva"
-version = "0.4.0"
+version = "0.6.0.dev1"
 source = { editable = "." }
 dependencies = [
     { name = "cryptography" },
@@ -1278,6 +1278,7 @@ dependencies = [
     { name = "pyinstrument" },
     { name = "structlog" },
     { name = "tortoise-orm", extra = ["accel"] },
+    { name = "typer" },
 ]
 
 [package.optional-dependencies]
@@ -1312,6 +1313,7 @@ requires-dist = [
     { name = "pytest-asyncio", marker = "extra == 'testing'", specifier = ">=0.25.3" },
     { name = "structlog", specifier = ">=25.5.0" },
     { name = "tortoise-orm", extras = ["accel"], specifier = ">=0.25.3" },
+    { name = "typer", specifier = ">=0.21.1" },
 ]
 provides-extras = ["testing"]