python-neva 3.2.0__py3-none-any.whl → 3.4.0__py3-none-any.whl

neva/arch/service_provider.py

@@ -175,6 +175,10 @@ class ServiceProvider(abc.ABC):
         _ = self.provider.decorate(source, provides=interface, scope=scope, when=when)
         return self
 
+    def from_context(self, interface: type, scope: Scope | None = None) -> None:
+        """Declares an interface as provided by the current context."""
+        _ = self.provider.from_context(provides=interface, scope=scope)
+
     @abc.abstractmethod
     def register(self) -> Result[Self, str]:
         """Register services into the application container.

neva/events/__init__.py

@@ -9,7 +9,8 @@ Three components are of particular interest:
 
 from neva.events.dispatcher import EventDispatcher
 from neva.events.event import Event
-from neva.events.listener import EventListener, HandlingPolicy, listener
+from neva.events.listener import EventListener, listener
+from neva.events.policy import HandlingPolicy
 from neva.events.provider import EventServiceProvider
 
 

neva/events/contracts/__init__.py

@@ -0,0 +1,20 @@
+from neva.events.contracts.dispatcher import (
+    AsyncBeforeDispatchHook,
+    BeforeDispatchHook,
+    EventDispatcher,
+    SyncBeforeDispatchHook,
+)
+from neva.events.contracts.event import Event
+from neva.events.contracts.handler import EventHandler
+from neva.events.contracts.listener import EventListener
+
+
+__all__ = [
+    "AsyncBeforeDispatchHook",
+    "BeforeDispatchHook",
+    "Event",
+    "EventDispatcher",
+    "EventHandler",
+    "EventListener",
+    "SyncBeforeDispatchHook",
+]

neva/events/contracts/dispatcher.py

@@ -0,0 +1,47 @@
+from typing import Protocol, runtime_checkable
+
+from neva.events.contracts.event import Event
+from neva.events.contracts.listener import EventListener
+from neva.support import Result
+
+
+@runtime_checkable
+class AsyncBeforeDispatchHook(Protocol):
+    """Asynchronous hook to be called before listeners are invoked."""
+
+    async def __call__(self, context: Event) -> None:
+        """Execute the hook."""
+
+
+@runtime_checkable
+class SyncBeforeDispatchHook(Protocol):
+    """Synchronous hook to be called before listeners are invoked."""
+
+    def __call__(self, context: Event) -> None:
+        """Execute the hook."""
+
+
+BeforeDispatchHook = AsyncBeforeDispatchHook | SyncBeforeDispatchHook
+
+
+class EventDispatcher(Protocol):
+    """Event dispatcher protocol."""
+
+    async def dispatch(
+        self,
+        event: Event,
+    ) -> list[Result[None, str]]:
+        """Dispatch an event to all registered listeners."""
+        ...
+
+    async def before_dispatch(self, hook: BeforeDispatchHook) -> None:
+        """Register a hook to be called before listeners are invoked."""
+        ...
+
+    def listen[T: Event](
+        self,
+        event_cls: type[T],
+        listener_cls: type[EventListener[T]],
+    ) -> None:
+        """Register a listener for an event."""
+        ...

neva/events/contracts/event.py

@@ -0,0 +1,7 @@
+import pydantic
+
+
+class Event(pydantic.BaseModel):
+    """Base Event class."""
+
+    pass

neva/events/contracts/handler.py

@@ -0,0 +1,14 @@
+from typing import Protocol
+
+from neva.events.contracts.event import Event
+from neva.support import Result
+
+
+class EventHandler[T: Event](Protocol):
+    """Define a valid function for event handling."""
+
+    __name__: str
+
+    async def __call__(self, event: T) -> Result[None, str]:
+        """Handle an event."""
+        ...

neva/events/contracts/listener.py

@@ -0,0 +1,19 @@
+from typing import Protocol
+
+from neva.events.contracts.event import Event
+from neva.events.policy import HandlingPolicy
+from neva.support import Result
+
+
+class EventListener[T: Event](Protocol):
+    """Event listener protocol."""
+
+    policy: HandlingPolicy
+
+    async def handle(self, event: T) -> Result[None, str]:
+        """Handle an event.
+
+        Returns:
+            A result indicating whether the event was handled successfully.
+        """
+        ...

neva/events/dispatcher.py

@@ -1,15 +1,16 @@
 """Base implementation of the event dispatcher."""
 
+from typing import override
+
 from neva.arch.application import Application
 from neva.database.manager import DatabaseManager
 from neva.database.transaction import TransactionCallback
-from neva.events.event import Event
+from neva.events import contracts
 from neva.events.event_registry import EventRegistry
-from neva.events.listener import EventListener
 from neva.support import Err, Nothing, Result, Some
 
 
-class EventDispatcher:
+class EventDispatcher(contracts.EventDispatcher):
     """Event dispatcher implementation."""
 
     def __init__(
@@ -18,11 +19,12 @@ class EventDispatcher:
         db: DatabaseManager,
         registry: EventRegistry,
     ) -> None:
-        self._registry = registry
-        self._app = app
-        self._db = db
+        self._registry: EventRegistry = registry
+        self._app: Application = app
+        self._db: DatabaseManager = db
+        self._before_dispatch_hooks: list[contracts.BeforeDispatchHook] = []
 
-    async def _before_dispatch(self, event: Event) -> None:
+    async def _apply_before_dispatch(self, event: contracts.Event) -> None:
         """Extension hook called before listeners are invoked.
 
         Override in a subclass to add cross-cutting behaviour such as
@@ -32,8 +34,20 @@ class EventDispatcher:
         Args:
             event: The event about to be dispatched.
         """
-
-    async def dispatch(self, event: Event) -> list[Result[None, str]]:
+        for hook in self._before_dispatch_hooks:
+            match hook:
+                case contracts.AsyncBeforeDispatchHook():
+                    await hook(event)
+                case contracts.SyncBeforeDispatchHook():
+                    hook(event)
+
+    @override
+    async def before_dispatch(self, hook: contracts.BeforeDispatchHook) -> None:
+        """Register a hook to be called before listeners are invoked."""
+        self._before_dispatch_hooks.append(hook)
+
+    @override
+    async def dispatch(self, event: contracts.Event) -> list[Result[None, str]]:
         """Dispatch an event to all registered listeners.
 
         Listeners are resolved from the DI container when available,
@@ -45,20 +59,23 @@ class EventDispatcher:
         Returns:
             A list of results, one per listener invocation.
         """
-        await self._before_dispatch(event)
+        await self._apply_before_dispatch(event)
         results: list[Result[None, str]] = []
-        listeners = self._registry.get_listeners(event)
+        listeners = self._registry.resolve_listeners(event)
 
-        to_execute = listeners.immediate.copy()
+        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]
 
         match self._db.current():
             case Some(tx):
-                for listener_cls in listeners.deferred:
+                for listener_cls in deferred:
                     _ = tx.on_commit(self._build_callback(event, listener_cls))
             case Nothing():
-                to_execute += listeners.deferred
+                immediate.extend(deferred)
 
-        for listener_cls in to_execute:
+        for listener_cls in immediate:
             listener = self._resolve_listener(listener_cls)
             try:
                 results.append(await listener.handle(event))
@@ -67,17 +84,20 @@ class EventDispatcher:
 
         return results
 
-    def listen[T: Event](
+    @override
+    def listen[T: contracts.Event](
         self,
-        event_cls: type[T],
-        listener_cls: type[EventListener[T]],
+        event_cls: type[T] | list[type[T]],
+        listener_cls: type[contracts.EventListener[T]],
     ) -> None:
         """Register a listener for an event."""
+        if not isinstance(event_cls, list):
+            event_cls = [event_cls]
         self._registry.register(event_cls, listener_cls)
 
-    def _resolve_listener[T: Event](
-        self, listener_cls: type[EventListener[T]]
-    ) -> EventListener[T]:
+    def _resolve_listener[T: contracts.Event](
+        self, listener_cls: type[contracts.EventListener[T]]
+    ) -> contracts.EventListener[T]:
         """Resolve a listener from the container.
 
         Listeners are resolved from the DI container when available,
@@ -91,10 +111,10 @@ class EventDispatcher:
             return result.unwrap()
         return listener_cls()
 
-    def _build_callback[T: Event](
+    def _build_callback[T: contracts.Event](
         self,
         event: T,
-        listener_cls: type[EventListener[T]],
+        listener_cls: type[contracts.EventListener[T]],
     ) -> TransactionCallback:
         async def callback() -> Result[None, str]:
             listener = self._resolve_listener(listener_cls)

neva/events/event.py

@@ -4,10 +4,11 @@ import datetime as dt
 
 import pydantic
 
+from neva.events import contracts
 from neva.support import time
 
 
-class Event[T](pydantic.BaseModel):
+class Event[T](contracts.Event):
     """Base event class."""
 
     event_id: T

neva/events/event_registry.py

@@ -1,27 +1,30 @@
 """Event/listener registry."""
 
-from typing import Any
+import inspect
+from typing import Any, TypeVar
 
-from neva.events.event import Event
-from neva.events.listener import EventListener, HandlingPolicy
+from neva.events import contracts, policy
 
 
-class EventListenerRegistry[T: Event]:
+class EventListenerRegistry[T: contracts.Event]:
     """Event listener registry for a given event."""
 
     def __init__(self) -> None:
-        self.immediate: list[type[EventListener[T]]] = []
-        self.deferred: list[type[EventListener[T]]] = []
+        self.immediate: list[type[contracts.EventListener[T]]] = []
+        self.deferred: list[type[contracts.EventListener[T]]] = []
 
-    def add_listener(self, listener_cls: type[EventListener[T]]) -> None:
+    def add_listener(self, listener_cls: type[contracts.EventListener[T]]) -> None:
         """Add a listener to the correct category in the registry."""
         match listener_cls.policy:
-            case HandlingPolicy.IMMEDIATE:
+            case policy.HandlingPolicy.IMMEDIATE:
                 self.immediate.append(listener_cls)
-            case HandlingPolicy.DEFERRED:
+            case policy.HandlingPolicy.DEFERRED:
                 self.deferred.append(listener_cls)
 
 
+T = TypeVar("T", bound=contracts.Event, covariant=True)
+
+
 class EventRegistry:
     """Event/listener registry."""
 
@@ -31,14 +34,26 @@ class EventRegistry:
         """Initialize the registry."""
         self.__listeners = {}
 
-    def register[T: Event](
-        self, event_cls: type[T], listener_cls: type[EventListener[T]]
+    def register(
+        self,
+        event_cls: list[type[T]],
+        listener_cls: type[contracts.EventListener[T]],
     ) -> None:
         """Register a listener for an event."""
-        self.__listeners.setdefault(event_cls, EventListenerRegistry()).add_listener(
-            listener_cls
-        )
-
-    def get_listeners[T: Event](self, event: T) -> EventListenerRegistry[T]:
+        for cls in event_cls:
+            self.__listeners.setdefault(cls, EventListenerRegistry()).add_listener(
+                listener_cls
+            )
+
+    def resolve_listeners(self, event: T) -> list[EventListenerRegistry[T]]:
+        """Return all listeners registries for an event type."""
+        registries = [
+            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]())

neva/events/listener.py

@@ -1,49 +1,26 @@
 """Event listener protocol."""
 
-import abc
-from enum import StrEnum
 from types import new_class
-from typing import Callable, Protocol
+from typing import Callable, override
 
-from neva.events.event import Event
+from neva.events import contracts
+from neva.events.policy import HandlingPolicy
 from neva.support import Result
 from neva.support.strconv import snake2pascal
 
 
-class HandlingPolicy(StrEnum):
-    """Event dispatch policy."""
-
-    IMMEDIATE = "immediate"
-    DEFERRED = "deferred"
-
-
-class EventListener[T: Event](abc.ABC):
-    """Event listener protocol."""
+class EventListener[T: contracts.Event](contracts.EventListener[T]):
+    """Base event listener class."""
 
     policy: HandlingPolicy = HandlingPolicy.IMMEDIATE
 
-    @abc.abstractmethod
-    async def handle(self, event: T) -> Result[None, str]:
-        """Handle an event.
-
-        Returns:
-            A result indicating whether the event was handled successfully.
-        """
-
-
-class EventHandler[T: Event](Protocol):
-    """Define a valid function for event handling."""
-
-    __name__: str
-
-    async def __call__(self, event: T) -> Result[None, str]:
-        """Handle an event."""
-        ...
+    @override
+    async def handle(self, event: contracts.Event) -> Result[None, str]: ...
 
 
-def listener[T: Event](
+def listener[T: contracts.Event](
     policy: HandlingPolicy = HandlingPolicy.IMMEDIATE,
-) -> Callable[[EventHandler[T]], type[EventListener[T]]]:
+) -> Callable[[contracts.EventHandler[T]], type[EventListener[T]]]:
     """Create a listener from a function.
 
     Returns:
@@ -51,7 +28,7 @@ def listener[T: Event](
     """
 
     def decorator(
-        func: EventHandler[T],
+        func: contracts.EventHandler[T],
     ) -> type[EventListener[T]]:
         async def handle(_: EventListener[T], event: T) -> Result[None, str]:
             return await func(event)

neva/events/policy.py

@@ -0,0 +1,8 @@
+import enum
+
+
+class HandlingPolicy(enum.StrEnum):
+    """Determines when a listener is invoked."""
+
+    IMMEDIATE = "immediate"
+    DEFERRED = "deferred"

neva/events/provider.py

@@ -3,6 +3,8 @@
 from typing import Self, override
 
 from neva.arch.service_provider import ServiceProvider
+from neva.events import contracts
+from neva.events.dispatcher import EventDispatcher
 from neva.events.event_registry import EventRegistry
 from neva.support import Ok, Result
 
@@ -22,8 +24,7 @@ class EventServiceProvider(ServiceProvider):
         Returns:
             Result[Self, str]: The result of the registration.
         """
-        from neva.events.dispatcher import EventDispatcher
-
         self.bind(EventRegistry)
         self.bind(EventDispatcher)
+        self.bind(EventDispatcher, interface=contracts.EventDispatcher)
         return Ok(self)

neva/support/facade/event.pyi

@@ -2,9 +2,8 @@
 
 from typing import override
 
-from neva import events
 from neva.arch import Facade
-from neva.events import EventListener
+from neva.events import contracts
 from neva.support import Result
 
 class Event(Facade):
@@ -14,10 +13,10 @@ class Event(Facade):
     @override
     def get_facade_accessor(cls) -> type: ...
     @classmethod
-    async def dispatch(cls, event: events.Event) -> list[Result[None, str]]: ...
+    async def dispatch(cls, event: contracts.Event) -> list[Result[None, str]]: ...
     @classmethod
-    def listen[T: events.Event](
+    def listen[T: contracts.Event](
         cls,
         event_cls: type[T],
-        listener_cls: type[EventListener[T]],
+        listener_cls: type[contracts.EventListener[T]],
     ) -> None: ...

neva/testing/fakes.py

@@ -1,19 +1,20 @@
 """Testing fakes for Neva facades."""
 
 from collections.abc import Callable
-from typing import Any
+from typing import override
 
-from neva.events.event import Event as BaseEvent
+from neva.events import contracts
 from neva.support import Result
 
 
-class EventFake:
+class EventFake(contracts.EventDispatcher):
     """Recording fake for the Event facade. No listeners are dispatched."""
 
     def __init__(self) -> None:
-        self._dispatched: list[BaseEvent[Any]] = []
+        self._dispatched: list[contracts.Event] = []
 
-    async def dispatch(self, event: BaseEvent[Any]) -> list[Result[None, str]]:
+    @override
+    async def dispatch(self, event: contracts.Event) -> list[Result[None, str]]:
         """Record the event without invoking any listeners.
 
         Returns:
@@ -22,10 +23,17 @@ class EventFake:
         self._dispatched.append(event)
         return []
 
-    def listen[T: BaseEvent[Any]](self, event_cls: type[T], listener_cls: type) -> None:
+    @override
+    def listen[T: contracts.Event](
+        self, event_cls: type[T], listener_cls: type[contracts.EventListener[T]]
+    ) -> None:
         """No-op."""
 
-    def dispatched[E: BaseEvent[Any]](self, event_cls: type[E]) -> list[E]:
+    @override
+    async def before_dispatch(self, hook: contracts.BeforeDispatchHook) -> None:
+        """Register a hook to be called before listeners are invoked."""
+
+    def dispatched[E: contracts.Event](self, event_cls: type[E]) -> list[E]:
         """Return all recorded events of the given type.
 
         Returns:
@@ -33,7 +41,7 @@ class EventFake:
         """
         return [e for e in self._dispatched if isinstance(e, event_cls)]
 
-    def assert_dispatched[E: BaseEvent[Any]](
+    def assert_dispatched[E: contracts.Event](
         self,
         event_cls: type[E],
         *,
@@ -61,7 +69,7 @@ class EventFake:
         if match is not None and not any(match(e) for e in matching):
             raise AssertionError(f"No {event_cls.__name__} matched the predicate")
 
-    def assert_not_dispatched[E: BaseEvent[Any]](self, event_cls: type[E]) -> None:
+    def assert_not_dispatched[E: contracts.Event](self, event_cls: type[E]) -> None:
         """Assert that no event of the given type was dispatched.
 
         Args:

{python_neva-3.2.0.dist-info → python_neva-3.4.0.dist-info}/METADATA

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

{python_neva-3.2.0.dist-info → python_neva-3.4.0.dist-info}/RECORD

@@ -5,7 +5,7 @@ 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=zEFwix2cL6l1Frv9w1OMtnL_zjkl_BVpGBhRaNK6bb0,5636
+neva/arch/service_provider.py,sha256=SqL3uQGBh7aDIc_Lcp8Ijr3fdOtB8wbsmMnjU4GuUy4,5862
 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
@@ -20,13 +20,19 @@ neva/database/manager.py,sha256=VNvhVumZD2hoGKpkdXMAkT6KykE4H80WcG2DgShK5Hs,4240
 neva/database/provider.py,sha256=l2be4Ri53RtQq1-qzohy3cqzJQpTaNzqXGVhXPKUCXc,1674
 neva/database/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 neva/database/transaction.py,sha256=_0Dsao_vhCJT5YRUmrHOLb0uxvfdE-5k3n0yMPLC1o8,5167
-neva/events/__init__.py,sha256=xwIAXNcOASpuCY4DJpshZc1gtxQHimzwy-s7c-4QuiQ,746
-neva/events/dispatcher.py,sha256=mSjOvP1-new7z2QRBY3cbUzZ1Y_mlHSXMRt4NGhB8e0,3295
-neva/events/event.py,sha256=g3vAx-2qiR3QRM_or8G9mK5qx66A2LZiZ3n517R4lGQ,251
-neva/events/event_registry.py,sha256=jucYOUjCERz-ICdPiDrxYw_ySvmPJOcRzYKCgka29qY,1491
-neva/events/listener.py,sha256=-7RQOhVusKN8lopB3T2yfoQVlxX6GOSM5Pk1mPEMMro,1833
-neva/events/provider.py,sha256=HE7k915m8lQiqBC6kaGtb3ZfoxrgsuXXZmxkaaSnlmM,857
+neva/events/__init__.py,sha256=Gpi5q-pNlIi-q23U2ZOsNf8Y9rB6AQtsBbbBFU0tkFc,776
+neva/events/dispatcher.py,sha256=5M8s3aVzx9lIViGkigtu1kq6gFbam4OKDajuWNGuqA0,4376
+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/policy.py,sha256=I67ziob0IEVeXdkilNPpj2f48gEz2EZneR1Fz8Nlt2U,154
+neva/events/provider.py,sha256=cVxADLv7VXCK6gTMJsDNRzspMOH2lrIkvMRhqVh2cK4,954
 neva/events/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neva/events/contracts/__init__.py,sha256=t1VafYtzOZIF78V8X3K_Fg79Hw4FjSqasjLs0EQVIFA,489
+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
+neva/events/contracts/listener.py,sha256=0xwPrjprkMzXu9vY1Z-EjSLFdvOUpomiE65hH16nfxA,465
 neva/obs/__init__.py,sha256=dVzgljk9Hvo44LI34RcwbDyT42_z4nSnFVmL4GLbKD0,331
 neva/obs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 neva/obs/instrumentation/__init__.py,sha256=SfIAvuCs-L0kEzOxUJ4aOIkhbydCe7qBwWtGeDELVA0,36
@@ -75,16 +81,16 @@ neva/support/facade/crypt.pyi,sha256=_MV_qXDATaCs1pZTOw_-qPx_jjH_nG4-tUBOMX4nZIE
 neva/support/facade/db.py,sha256=mXMzuCKf390ICCBgzaub1ZoMqUBgOQByQYMEM3YnN_0,324
 neva/support/facade/db.pyi,sha256=UQFMgBuw0BGquMnuUNULC8Pdo7lDCVTCNkDaUmIZJhw,1911
 neva/support/facade/event.py,sha256=sRU-fxaRT59Fe-u2WTS5L9ncGkGLBndKa9gKbqwAq3M,1232
-neva/support/facade/event.pyi,sha256=wI1NlIg8p6j9jispsA6pI-kvNp81nwUM3ZP8O0zFaHk,558
+neva/support/facade/event.pyi,sha256=AL_v8fxkvtd9KwbiWbVuUAcdZz0yzLn8xZROFa6lXLE,546
 neva/support/facade/hash.py,sha256=tGhsvfGovt-mcRXSjDKf4jt1n7ib0eDPXFvRUfVxLUc,292
 neva/support/facade/hash.pyi,sha256=jTs3E5ZF5cp76jrgH70DEog8gzfYIcIV2PrO9xskHyI,1656
 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
-neva/testing/fakes.py,sha256=5HuuwMeAKhFSZfn9T8raQIjdgHkjFeZsFXDud0T4v7Q,2674
+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.2.0.dist-info/METADATA,sha256=2wZeNjt-ooHN3AIU1LE-K636R4shKM0-cIDXUGg1X2g,771
-python_neva-3.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-python_neva-3.2.0.dist-info/RECORD,,
+python_neva-3.4.0.dist-info/METADATA,sha256=rW3P72J2ukVUItHYsF1EDWCu4SJzGqv--6PjnYDnO5o,846
+python_neva-3.4.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+python_neva-3.4.0.dist-info/RECORD,,