eventsourcing 9.4.0a8__tar.gz → 9.4.0b1__tar.gz

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

@@ -1,13 +1,13 @@
 Metadata-Version: 2.3
 Name: eventsourcing
-Version: 9.4.0a8
+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.0a8 → 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,
@@ -352,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:
@@ -610,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] = []
@@ -817,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
@@ -947,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.
         """
@@ -961,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.0a8 → 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)

{eventsourcing-9.4.0a8 → eventsourcing-9.4.0b1}/eventsourcing/domain.py

@@ -88,20 +88,26 @@ class DomainEventProtocol(Protocol):
     kinds of domain event classes, such as Pydantic classes.
     """
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        pass  # pragma: no cover
+
     @property
     def originator_id(self) -> UUID:
         """
         UUID identifying an aggregate to which the event belongs.
         """
+        raise NotImplementedError  # pragma: no cover
 
     @property
     def originator_version(self) -> int:
         """
         Integer identifying the version of the aggregate when the event occurred.
         """
+        raise NotImplementedError  # pragma: no cover
 
 
 TDomainEvent = TypeVar("TDomainEvent", bound=DomainEventProtocol)
+SDomainEvent = TypeVar("SDomainEvent", bound=DomainEventProtocol)
 
 
 class MutableAggregateProtocol(Protocol):
@@ -120,18 +126,21 @@ class MutableAggregateProtocol(Protocol):
         """
         Mutable aggregates have a read-only ID that is a UUID.
         """
+        raise NotImplementedError  # pragma: no cover
 
     @property
     def version(self) -> int:
         """
         Mutable aggregates have a read-write version that is an int.
         """
+        raise NotImplementedError  # pragma: no cover
 
     @version.setter
     def version(self, value: int) -> None:
         """
         Mutable aggregates have a read-write version that is an int.
         """
+        raise NotImplementedError  # pragma: no cover
 
 
 class ImmutableAggregateProtocol(Protocol):
@@ -150,12 +159,14 @@ class ImmutableAggregateProtocol(Protocol):
         """
         Immutable aggregates have a read-only ID that is a UUID.
         """
+        raise NotImplementedError  # pragma: no cover
 
     @property
     def version(self) -> int:
         """
         Immutable aggregates have a read-only version that is an int.
         """
+        raise NotImplementedError  # pragma: no cover
 
 
 MutableOrImmutableAggregate = Union[
@@ -180,6 +191,7 @@ class CollectEventsProtocol(Protocol):
         """
         Returns a sequence of events.
         """
+        raise NotImplementedError  # pragma: no cover
 
 
 @runtime_checkable
@@ -233,7 +245,7 @@ class CanCreateTimestamp:
         return datetime_now_with_tzinfo()
 
 
-TAggregate = TypeVar("TAggregate", bound="Aggregate")
+TAggregate = TypeVar("TAggregate", bound="BaseAggregate")
 
 
 class HasOriginatorIDVersion:
@@ -300,7 +312,7 @@ class CanMutateAggregate(HasOriginatorIDVersion, CanCreateTimestamp):
         # Return the mutated aggregate.
         return aggregate
 
-    def apply(self, aggregate: Aggregate) -> None:
+    def apply(self, aggregate: Any) -> None:
         """
         Applies the domain event to its aggregate.
 
@@ -934,9 +946,9 @@ def _raise_missing_names_type_error(missing_names: list[str], msg: str) -> None:
     raise TypeError(msg)
 
 
-_annotations_mention_id: set[type[Aggregate]] = set()
-_init_mentions_id: set[type[Aggregate]] = set()
-_create_id_param_names: dict[type[Aggregate], list[str]] = defaultdict(list)
+_annotations_mention_id: set[type[BaseAggregate]] = set()
+_init_mentions_id: set[type[BaseAggregate]] = set()
+_create_id_param_names: dict[type[BaseAggregate], list[str]] = defaultdict(list)
 
 
 class MetaAggregate(EventsourcingType, Generic[TAggregate], type):
@@ -1011,19 +1023,13 @@ class MetaAggregate(EventsourcingType, Generic[TAggregate], type):
     _created_event_class: type[CanInitAggregate]
 
 
-class Aggregate(metaclass=MetaAggregate):
+class BaseAggregate(metaclass=MetaAggregate):
     """
     Base class for aggregates.
     """
 
     INITIAL_VERSION = 1
 
-    class Event(AggregateEvent):
-        pass
-
-    class Created(Event, AggregateCreated):
-        pass
-
     @staticmethod
     def create_id(*_: Any, **__: Any) -> UUID:
         """
@@ -1081,7 +1087,7 @@ class Aggregate(metaclass=MetaAggregate):
 
         assert agg is not None
         # Append the domain event to pending list.
-        agg.pending_events.append(created_event)
+        agg._pending_events.append(created_event)
         # Return the aggregate.
         return agg
 
@@ -1197,7 +1203,7 @@ class Aggregate(metaclass=MetaAggregate):
         return f"{type(self).__name__}({', '.join(attrs)})"
 
     def __init_subclass__(
-        cls: type[Aggregate], *, created_event_name: str | None = None
+        cls: type[BaseAggregate], *, created_event_name: str | None = None
     ) -> None:
         """
         Initialises aggregate subclass by defining __init__ method and event classes.
@@ -1211,8 +1217,10 @@ class Aggregate(metaclass=MetaAggregate):
         except KeyError:
             pass
 
-        if class_annotations or any(
-            dataclasses.is_dataclass(base) for base in cls.__bases__
+        if (
+            class_annotations
+            or cls in _annotations_mention_id
+            or any(dataclasses.is_dataclass(base) for base in cls.__bases__)
         ):
             dataclasses.dataclass(eq=False, repr=False)(cls)
 
@@ -1223,7 +1231,9 @@ class Aggregate(metaclass=MetaAggregate):
             base_event_cls = cls.__dict__[base_event_name]
         except KeyError:
             base_event_cls = cls._define_event_class(
-                base_event_name, (cls.Event,), None
+                name=base_event_name,
+                bases=(getattr(cls, base_event_name, AggregateEvent),),
+                apply_method=None,
             )
             setattr(cls, base_event_name, base_event_cls)
 
@@ -1482,9 +1492,12 @@ class Aggregate(metaclass=MetaAggregate):
                     setattr(cls, name, sub_class)
 
 
-# Special case for the Aggregate class because
-# it's not processed by Aggregate.__init_subclass__.
-_created_event_classes[Aggregate] = [Aggregate.Created]
+class Aggregate(BaseAggregate):
+    class Event(AggregateEvent):
+        pass
+
+    class Created(Event, AggregateCreated):
+        pass
 
 
 @overload
@@ -1578,6 +1591,7 @@ class SnapshotProtocol(DomainEventProtocol, Protocol):
         """
         Snapshots have a read-only 'state'.
         """
+        raise NotImplementedError  # pragma: no cover
 
     # TODO: Improve on this 'Any'.
     @classmethod
@@ -1594,6 +1608,16 @@ class CanSnapshotAggregate(HasOriginatorIDVersion, CanCreateTimestamp):
     topic: str
     state: Any
 
+    def __init__(
+        self,
+        originator_id: UUID,
+        originator_version: int,
+        timestamp: datetime,
+        topic: str,
+        state: Any,
+    ) -> None:
+        raise NotImplementedError  # pragma: no cover
+
     @classmethod
     def take(
         cls: type[TCanSnapshotAggregate],
@@ -1610,7 +1634,7 @@ class CanSnapshotAggregate(HasOriginatorIDVersion, CanCreateTimestamp):
             aggregate_state.pop("_id")
             aggregate_state.pop("_version")
             aggregate_state.pop("_pending_events")
-        return cls(  # type: ignore
+        return cls(
             originator_id=aggregate.id,
             originator_version=aggregate.version,
             timestamp=cls.create_timestamp(),

{eventsourcing-9.4.0a8 → eventsourcing-9.4.0b1}/eventsourcing/interface.py

@@ -141,7 +141,7 @@ class NotificationLogJSONClient(NotificationLog):
         self,
         start: int | None,
         limit: int,
-        _: int | None = None,
+        stop: int | None = None,
         topics: Sequence[str] = (),
         *,
         inclusive_of_start: bool = True,

{eventsourcing-9.4.0a8 → eventsourcing-9.4.0b1}/eventsourcing/persistence.py

@@ -517,10 +517,10 @@ class TrackingRecorder(Recorder, ABC):
         interrupt: Event | None = None,
     ) -> None:
         """
-        Block until a tracking object with the given application name and
-        notification ID has been recorded.
+        Block until a tracking object with the given application name and a
+        notification ID greater than equal to the given value has been recorded.
 
-        Polls has_tracking_id() with exponential backoff until the timeout
+        Polls max_tracking_id() with exponential backoff until the timeout
         is reached, or until the optional interrupt event is set.
 
         The timeout argument should be a floating point number specifying a
@@ -534,7 +534,10 @@ class TrackingRecorder(Recorder, ABC):
         deadline = monotonic() + timeout
         delay_ms = 1.0
         while True:
-            if self.has_tracking_id(application_name, notification_id):
+            max_tracking_id = self.max_tracking_id(application_name)
+            if notification_id is None or (
+                max_tracking_id is not None and max_tracking_id >= notification_id
+            ):
                 break
             if interrupt:
                 if interrupt.wait(timeout=delay_ms / 1000):
@@ -751,6 +754,7 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
             mapper_topic = self.env.get(self.MAPPER_TOPIC)
             mapper_class = resolve_topic(mapper_topic) if mapper_topic else Mapper
 
+        assert isinstance(mapper_class, type) and issubclass(mapper_class, Mapper)
         return mapper_class(
             transcoder=transcoder or self.transcoder(),
             cipher=self.cipher(),