eventsourcing 9.4.0a7__tar.gz → 9.4.0b1__tar.gz

{eventsourcing-9.4.0a7 → eventsourcing-9.4.0b1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.3
 Name: eventsourcing
-Version: 9.4.0a7
+Version: 9.4.0b1
 Summary: Event sourcing in Python
 License: BSD 3-Clause
 Keywords: event sourcing,event store,domain driven design,domain-driven design,ddd,cqrs,cqs
 Author: John Bywater
 Author-email: john.bywater@appropriatesoftware.net
 Requires-Python: >=3.9, !=2.7.*, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*, !=3.8.*
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Science/Research

{eventsourcing-9.4.0a7 → eventsourcing-9.4.0b1}/eventsourcing/application.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import os
 from abc import ABC, abstractmethod
 from collections.abc import Iterable, Iterator, Sequence
@@ -26,6 +27,7 @@ from eventsourcing.domain import (
     DomainEventProtocol,
     EventSourcingError,
     MutableOrImmutableAggregate,
+    SDomainEvent,
     Snapshot,
     SnapshotProtocol,
     TDomainEvent,
@@ -43,7 +45,6 @@ from eventsourcing.persistence import (
     Notification,
     Recording,
     Tracking,
-    TrackingRecorder,
     Transcoder,
     UUIDAsHex,
 )
@@ -95,10 +96,9 @@ class Cache(Generic[S, T]):
             return self.cache.pop(key)
         return self.cache[key]
 
-    def put(self, key: S, value: T) -> T | None:
+    def put(self, key: S, value: T | None) -> None:
         if value is not None:
             self.cache[key] = value
-        return None
 
 
 class LRUCache(Cache[S, T]):
@@ -153,7 +153,7 @@ class LRUCache(Cache[S, T]):
                 return result
             raise KeyError
 
-    def put(self, key: S, value: T) -> Any | None:
+    def put(self, key: S, value: T | None) -> Any | None:
         evicted_key = None
         evicted_value = None
         with self.lock:
@@ -354,19 +354,18 @@ class Repository:
         return aggregate
 
     def _use_fastforward_lock(self, aggregate_id: UUID) -> Lock:
+        lock: Lock | None = None
         with self._fastforward_locks_lock:
-            try:
+            num_users = 0
+            with contextlib.suppress(KeyError):
                 lock, num_users = self._fastforward_locks_inuse[aggregate_id]
-            except KeyError:
-                try:
+            if lock is None:
+                with contextlib.suppress(KeyError):
                     lock = self._fastforward_locks_cache.get(aggregate_id, evict=True)
-                except KeyError:
-                    lock = Lock()
-                finally:
-                    num_users = 0
-            finally:
-                num_users += 1
-                self._fastforward_locks_inuse[aggregate_id] = (lock, num_users)
+            if lock is None:
+                lock = Lock()
+            num_users += 1
+            self._fastforward_locks_inuse[aggregate_id] = (lock, num_users)
             return lock
 
     def _disuse_fastforward_lock(self, aggregate_id: UUID) -> None:
@@ -612,12 +611,10 @@ class Application:
     name = "Application"
     env: ClassVar[dict[str, str]] = {}
     is_snapshotting_enabled: bool = False
-    snapshotting_intervals: ClassVar[
-        dict[type[MutableOrImmutableAggregate], int] | None
-    ] = None
+    snapshotting_intervals: ClassVar[dict[type[MutableOrImmutableAggregate], int]] = {}
     snapshotting_projectors: ClassVar[
-        dict[type[MutableOrImmutableAggregate], ProjectorFunction[Any, Any]] | None
-    ] = None
+        dict[type[MutableOrImmutableAggregate], ProjectorFunction[Any, Any]]
+    ] = {}
     snapshot_class: type[SnapshotProtocol] = Snapshot
     log_section_size = 10
     notify_topics: Sequence[str] = []
@@ -690,9 +687,7 @@ class Application:
             _env.update(env)
         return Environment(name, _env)
 
-    def construct_factory(
-        self, env: Environment
-    ) -> InfrastructureFactory[TrackingRecorder]:
+    def construct_factory(self, env: Environment) -> InfrastructureFactory:
         """
         Constructs an :class:`~eventsourcing.persistence.InfrastructureFactory`
         for use by the application.
@@ -821,12 +816,9 @@ class Application:
                     continue
                 interval = self.snapshotting_intervals.get(type(aggregate))
                 if interval is not None and event.originator_version % interval == 0:
-                    if (
-                        self.snapshotting_projectors
-                        and type(aggregate) in self.snapshotting_projectors
-                    ):
+                    try:
                         projector_func = self.snapshotting_projectors[type(aggregate)]
-                    else:
+                    except KeyError:
                         projector_func = project_aggregate
                     if projector_func is project_aggregate and not isinstance(
                         event, CanMutateProtocol
@@ -951,10 +943,10 @@ class EventSourcedLog(Generic[TDomainEvent]):
 
     def _trigger_event(
         self,
-        logged_cls: type[T] | None,
+        logged_cls: type[SDomainEvent],
         next_originator_version: int | None = None,
         **kwargs: Any,
-    ) -> T:
+    ) -> SDomainEvent:
         """
         Constructs and returns a new log event.
         """
@@ -965,7 +957,7 @@ class EventSourcedLog(Generic[TDomainEvent]):
             else:
                 next_originator_version = last_logged.originator_version + 1
 
-        return logged_cls(  # type: ignore
+        return logged_cls(
             originator_id=self.originator_id,
             originator_version=next_originator_version,
             timestamp=datetime_now_with_tzinfo(),

{eventsourcing-9.4.0a7 → eventsourcing-9.4.0b1}/eventsourcing/cipher.py

@@ -5,7 +5,9 @@ from base64 import b64decode, b64encode
 from typing import TYPE_CHECKING
 
 from Crypto.Cipher import AES
-from Crypto.Cipher._mode_gcm import GcmMode
+from Crypto.Cipher._mode_gcm import (
+    GcmMode,  # pyright: ignore [reportPrivateImportUsage]
+)
 from Crypto.Cipher.AES import key_size
 
 from eventsourcing.persistence import Cipher

eventsourcing-9.4.0b1/eventsourcing/dispatch.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import functools
+from typing import TYPE_CHECKING, Any, Callable, Generic, TypeVar, cast, overload
+
+_T = TypeVar("_T")
+_S = TypeVar("_S")
+
+if TYPE_CHECKING:
+
+    class _singledispatchmethod(functools.singledispatchmethod[_T]):  # noqa: N801
+        pass
+
+else:
+
+    class _singledispatchmethod(  # noqa: N801
+        functools.singledispatchmethod, Generic[_T]
+    ):
+        pass
+
+
+class singledispatchmethod(_singledispatchmethod[_T]):  # noqa: N801
+    def __init__(self, func: Callable[..., _T]) -> None:
+        super().__init__(func)
+        self.deferred_registrations: list[
+            tuple[type[Any] | Callable[..., _T], Callable[..., _T] | None]
+        ] = []
+
+    @overload
+    def register(
+        self, cls: type[Any], method: None = None
+    ) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ...  # pragma: no cover
+    @overload
+    def register(
+        self, cls: Callable[..., _T], method: None = None
+    ) -> Callable[..., _T]: ...  # pragma: no cover
+
+    @overload
+    def register(
+        self, cls: type[Any], method: Callable[..., _T]
+    ) -> Callable[..., _T]: ...  # pragma: no cover
+
+    def register(
+        self,
+        cls: type[Any] | Callable[..., _T],
+        method: Callable[..., _T] | None = None,
+    ) -> Callable[[Callable[..., _T]], Callable[..., _T]] | Callable[..., _T]:
+        """generic_method.register(cls, func) -> func
+
+        Registers a new implementation for the given *cls* on a *generic_method*.
+        """
+        if isinstance(cls, (classmethod, staticmethod)):
+            first_annotation = {}
+            for k, v in cls.__func__.__annotations__.items():
+                first_annotation[k] = v
+                break
+            cls.__annotations__ = first_annotation
+
+            # for globals in typing.get_type_hints() in Python 3.8 and 3.9
+            if not hasattr(cls, "__wrapped__"):
+                cls.__dict__["__wrapped__"] = cls.__func__
+                # cls.__wrapped__ = cls.__func__
+
+        try:
+            return self.dispatcher.register(cast(type[Any], cls), func=method)
+        except NameError:
+            self.deferred_registrations.append(
+                (cls, method)  # pyright: ignore [reportArgumentType]
+            )
+            # TODO: Fix this....
+            return method or cls  # pyright: ignore [reportReturnType]
+
+    def __get__(self, obj: _S, cls: type[_S] | None = None) -> Callable[..., _T]:
+        for registered_cls, registered_method in self.deferred_registrations:
+            self.dispatcher.register(
+                cast(type[Any], registered_cls), func=registered_method
+            )
+        self.deferred_registrations = []
+        return super().__get__(obj, cls=cls)