eventsourcing 9.4.0a5__py3-none-any.whl → 9.4.0a7__py3-none-any.whl

eventsourcing/application.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import os
 from abc import ABC, abstractmethod
+from collections.abc import Iterable, Iterator, Sequence
 from copy import deepcopy
 from dataclasses import dataclass
 from itertools import chain
@@ -11,22 +12,13 @@ from typing import (
     Any,
     Callable,
     ClassVar,
-    Dict,
     Generic,
-    Iterable,
-    Iterator,
-    List,
     Optional,
-    Sequence,
-    Tuple,
-    Type,
     TypeVar,
     cast,
 )
 from warnings import warn
 
-from typing_extensions import deprecated
-
 from eventsourcing.domain import (
     Aggregate,
     CanMutateProtocol,
@@ -96,7 +88,7 @@ T = TypeVar("T")
 
 class Cache(Generic[S, T]):
     def __init__(self) -> None:
-        self.cache: Dict[S, Any] = {}
+        self.cache: dict[S, Any] = {}
 
     def get(self, key: S, *, evict: bool = False) -> T:
         if evict:
@@ -127,7 +119,7 @@ class LRUCache(Cache[S, T]):
         self.maxsize = maxsize
         self.full = False
         self.lock = Lock()  # because linkedlist updates aren't threadsafe
-        self.root: List[Any] = []  # root of the circular doubly linked list
+        self.root: list[Any] = []  # root of the circular doubly linked list
         self.clear()
 
     def clear(self) -> None:
@@ -253,7 +245,7 @@ class Repository:
         self._fastforward_locks_cache: LRUCache[UUID, Lock] = LRUCache(
             maxsize=self.FASTFORWARD_LOCKS_CACHE_MAXSIZE
         )
-        self._fastforward_locks_inuse: Dict[UUID, Tuple[Lock, int]] = {}
+        self._fastforward_locks_inuse: dict[UUID, tuple[Lock, int]] = {}
 
     def get(
         self,
@@ -415,12 +407,12 @@ class Section:
     Constructor arguments:
 
     :param Optional[str] id: section ID of this section e.g. "1,10"
-    :param List[Notification] items: a list of event notifications
+    :param list[Notification] items: a list of event notifications
     :param Optional[str] next_id: section ID of the following section
     """
 
     id: str | None
-    items: List[Notification]
+    items: list[Notification]
     next_id: str | None
 
 
@@ -446,7 +438,7 @@ class NotificationLog(ABC):
         topics: Sequence[str] = (),
         *,
         inclusive_of_start: bool = True,
-    ) -> List[Notification]:
+    ) -> list[Notification]:
         """
         Returns a selection of
         :class:`~eventsourcing.persistence.Notification` objects
@@ -536,7 +528,7 @@ class LocalNotificationLog(NotificationLog):
         topics: Sequence[str] = (),
         *,
         inclusive_of_start: bool = True,
-    ) -> List[Notification]:
+    ) -> list[Notification]:
         """
         Returns a selection of
         :class:`~eventsourcing.persistence.Notification` objects
@@ -573,9 +565,9 @@ class ProcessingEvent:
         Initialises the process event with the given tracking object.
         """
         self.tracking = tracking
-        self.events: List[DomainEventProtocol] = []
-        self.aggregates: Dict[UUID, MutableOrImmutableAggregate] = {}
-        self.saved_kwargs: Dict[Any, Any] = {}
+        self.events: list[DomainEventProtocol] = []
+        self.aggregates: dict[UUID, MutableOrImmutableAggregate] = {}
+        self.saved_kwargs: dict[Any, Any] = {}
 
     def collect_events(
         self,
@@ -618,15 +610,15 @@ class Application:
     """
 
     name = "Application"
-    env: ClassVar[Dict[str, str]] = {}
+    env: ClassVar[dict[str, str]] = {}
     is_snapshotting_enabled: bool = False
     snapshotting_intervals: ClassVar[
-        Dict[Type[MutableOrImmutableAggregate], int] | None
+        dict[type[MutableOrImmutableAggregate], int] | None
     ] = None
     snapshotting_projectors: ClassVar[
-        Dict[Type[MutableOrImmutableAggregate], ProjectorFunction[Any, Any]] | None
+        dict[type[MutableOrImmutableAggregate], ProjectorFunction[Any, Any]] | None
     ] = None
-    snapshot_class: Type[SnapshotProtocol] = Snapshot
+    snapshot_class: type[SnapshotProtocol] = Snapshot
     log_section_size = 10
     notify_topics: Sequence[str] = []
 
@@ -792,7 +784,7 @@ class Application:
         self,
         *objs: MutableOrImmutableAggregate | DomainEventProtocol | None,
         **kwargs: Any,
-    ) -> List[Recording]:
+    ) -> list[Recording]:
         """
         Collects pending events from given aggregates and
         puts them in the application's event store.
@@ -805,7 +797,7 @@ class Application:
         self.notify(processing_event.events)  # Deprecated.
         return recordings
 
-    def _record(self, processing_event: ProcessingEvent) -> List[Recording]:
+    def _record(self, processing_event: ProcessingEvent) -> list[Recording]:
         """
         Records given process event in the application's recorder.
         """
@@ -885,7 +877,7 @@ class Application:
         snapshot = snapshot_class.take(aggregate)
         self.snapshots.put([snapshot])
 
-    def notify(self, new_events: List[DomainEventProtocol]) -> None:
+    def notify(self, new_events: list[DomainEventProtocol]) -> None:
         """
         Deprecated.
 
@@ -895,7 +887,7 @@ class Application:
         need to take action when new domain events have been saved.
         """
 
-    def _notify(self, recordings: List[Recording]) -> None:
+    def _notify(self, recordings: list[Recording]) -> None:
         """
         Called after new aggregate events have been saved. This
         method on this class doesn't actually do anything,
@@ -911,14 +903,7 @@ class Application:
 TApplication = TypeVar("TApplication", bound=Application)
 
 
-@deprecated(
-    "AggregateNotFound is deprecated, use AggregateNotFoundError instead", category=None
-)
-class AggregateNotFound(EventSourcingError):  # noqa: N818
-    pass
-
-
-class AggregateNotFoundError(AggregateNotFound):
+class AggregateNotFoundError(EventSourcingError):
     """
     Raised when an :class:`~eventsourcing.domain.Aggregate`
     object is not found in a :class:`Repository`.
@@ -944,7 +929,7 @@ class EventSourcedLog(Generic[TDomainEvent]):
         self,
         events: EventStore,
         originator_id: UUID,
-        logged_cls: Type[TDomainEvent],  # TODO: Rename to 'event_class' in v10.
+        logged_cls: type[TDomainEvent],  # TODO: Rename to 'event_class' in v10.
     ):
         self.events = events
         self.originator_id = originator_id
@@ -966,7 +951,7 @@ class EventSourcedLog(Generic[TDomainEvent]):
 
     def _trigger_event(
         self,
-        logged_cls: Type[T] | None,
+        logged_cls: type[T] | None,
         next_originator_version: int | None = None,
         **kwargs: Any,
     ) -> T:

eventsourcing/domain.py

@@ -1,23 +1,18 @@
 from __future__ import annotations
 
+import dataclasses
+import importlib
 import inspect
 import os
-from dataclasses import dataclass
 from datetime import datetime, tzinfo
-from functools import lru_cache
+from functools import cache
 from types import FunctionType, WrapperDescriptorType
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    Dict,
     Generic,
-    Iterable,
-    List,
     Protocol,
-    Sequence,
-    Tuple,
-    Type,
     TypeVar,
     Union,
     cast,
@@ -29,6 +24,10 @@ from warnings import warn
 
 from eventsourcing.utils import get_method_name, get_topic, resolve_topic
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Sequence
+
+
 TZINFO: tzinfo = resolve_topic(os.getenv("TZINFO_TOPIC", "datetime:timezone.utc"))
 """
 A Python :py:obj:`tzinfo` object that defaults to UTC (:py:obj:`timezone.utc`). Used
@@ -294,7 +293,7 @@ class CanInitAggregate(CanMutateAggregate):
         assert aggregate is None
 
         # Resolve originator topic.
-        aggregate_class: Type[TAggregate] = resolve_topic(self.originator_topic)
+        aggregate_class: type[TAggregate] = resolve_topic(self.originator_topic)
 
         # Construct an aggregate object (a "shell" of the correct object type).
         agg = aggregate_class.__new__(aggregate_class)
@@ -333,12 +332,12 @@ class MetaDomainEvent(type):
     """
 
     def __new__(
-        cls, name: str, bases: Tuple[Type[TDomainEvent], ...], cls_dict: Dict[str, Any]
-    ) -> Type[TDomainEvent]:
+        cls, name: str, bases: tuple[type[TDomainEvent], ...], cls_dict: dict[str, Any]
+    ) -> type[TDomainEvent]:
         event_cls = cast(
-            Type[TDomainEvent], super().__new__(cls, name, bases, cls_dict)
+            type[TDomainEvent], super().__new__(cls, name, bases, cls_dict)
         )
-        event_cls = dataclass(frozen=True)(event_cls)
+        event_cls = dataclasses.dataclass(frozen=True)(event_cls)
         event_cls.__signature__ = inspect.signature(event_cls.__init__)  # type: ignore
         return event_cls
 
@@ -398,20 +397,20 @@ TLogEvent = TypeVar("TLogEvent", bound=DomainEventProtocol)
 
 
 def _filter_kwargs_for_method_params(
-    kwargs: Dict[str, Any], method: Callable[..., Any]
-) -> Dict[str, Any]:
+    kwargs: dict[str, Any], method: Callable[..., Any]
+) -> dict[str, Any]:
     names = _spec_filter_kwargs_for_method_params(method)
     return {k: v for k, v in kwargs.items() if k in names}
 
 
-@lru_cache(maxsize=None)
+@cache
 def _spec_filter_kwargs_for_method_params(method: Callable[..., Any]) -> set[str]:
     method_signature = inspect.signature(method)
     return set(method_signature.parameters)
 
 
 if TYPE_CHECKING:
-    EventSpecType = Union[str, Type[CanMutateAggregate]]
+    EventSpecType = Union[str, type[CanMutateAggregate]]
 
 CommandMethod = Callable[..., None]
 DecoratedObjType = Union[CommandMethod, property]
@@ -425,7 +424,7 @@ class CommandMethodDecorator:
         decorated_obj: DecoratedObjType,
     ):
         self.is_name_inferred_from_method = False
-        self.given_event_cls: Type[CanMutateAggregate] | None = None
+        self.given_event_cls: type[CanMutateAggregate] | None = None
         self.event_cls_name: str | None = None
         self.decorated_property: property | None = None
         self.is_property_setter = False
@@ -740,12 +739,12 @@ class BoundCommandMethodDecorator:
 
 
 given_event_classes: set[type] = set()
-decorated_methods: Dict[type, CommandMethod] = {}
-aggregate_has_many_created_event_classes: Dict[type, List[str]] = {}
+decorated_methods: dict[type, CommandMethod] = {}
+aggregate_has_many_created_event_classes: dict[type, list[str]] = {}
 
 
-decorated_event_classes: Dict[
-    CommandMethodDecorator, Type[MetaAggregate.DecoratedEvent]
+decorated_event_classes: dict[
+    CommandMethodDecorator, type[MetaAggregate.DecoratedEvent]
 ] = {}
 
 
@@ -767,10 +766,10 @@ def _check_no_variable_params(method: FunctionType) -> None:
 def _coerce_args_to_kwargs(
     method: FunctionType | WrapperDescriptorType,
     args: Iterable[Any],
-    kwargs: Dict[str, Any],
+    kwargs: dict[str, Any],
     *,
     expects_id: bool = False,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     assert isinstance(method, (FunctionType, WrapperDescriptorType))
 
     args = tuple(args)
@@ -789,14 +788,14 @@ def _coerce_args_to_kwargs(
     return copy_kwargs
 
 
-@lru_cache(maxsize=None)
+@cache
 def _spec_coerce_args_to_kwargs(
     method: FunctionType | WrapperDescriptorType,
     len_args: int,
-    kwargs_keys: Tuple[str],
+    kwargs_keys: tuple[str],
     *,
     expects_id: bool,
-) -> Tuple[Tuple[Tuple[int, str], ...], Tuple[Tuple[str, Any], ...]]:
+) -> tuple[tuple[tuple[int, str], ...], tuple[tuple[str, Any], ...]]:
     method_signature = inspect.signature(method)
     positional_names = []
     keyword_defaults = {}
@@ -874,7 +873,7 @@ def _spec_coerce_args_to_kwargs(
     return enumerated_args_names, keyword_defaults_items
 
 
-def _raise_missing_names_type_error(missing_names: List[str], msg: str) -> None:
+def _raise_missing_names_type_error(missing_names: list[str], msg: str) -> None:
     msg += missing_names[0]
     if len(missing_names) == 2:
         msg += f" and {missing_names[1]}"
@@ -888,6 +887,34 @@ _annotations_mention_id: set[MetaAggregate[Aggregate]] = set()
 _init_mentions_id: set[MetaAggregate[Aggregate]] = set()
 
 
+def _ensure_idempotent_dataclass(module_name: str) -> None:
+    module = importlib.import_module(module_name)
+    if (
+        "dataclass" in module.__dict__
+        and module.__dict__["dataclass"] == dataclasses.dataclass
+        and "__original_dataclass_func__" not in module.__dict__
+    ):
+        module.__dict__["__original_dataclass_func__"] = module.__dict__["dataclass"]
+        module.__dict__["dataclass"] = _idempotent_dataclass
+
+
+def _idempotent_dataclass(cls: type[object] | None = None, /, **kwargs: Any) -> Any:
+
+    def idempotent_wrap(cls: type[object]) -> type[object]:
+        # Avoid processing dataclass twice.
+        if "__dataclass_fields__" in cls.__dict__:
+            return cls
+        return dataclasses.dataclass(**kwargs)(cls)
+
+    # See if we're being called as @dataclass or @dataclass().
+    if cls is None:
+        # We're called with parens.
+        return idempotent_wrap
+
+    # We're called as @dataclass without parens.
+    return idempotent_wrap(cls)
+
+
 class MetaAggregate(type, Generic[TAggregate]):
     """
     Metaclass for aggregate classes.
@@ -920,12 +947,18 @@ class MetaAggregate(type, Generic[TAggregate]):
             # Call the original method with event attribute values.
             decorated_method(aggregate, **kwargs)
 
-    _created_event_class: Type[CanInitAggregate]
+    _created_event_class: type[CanInitAggregate]
 
     def __new__(cls, *args: Any, **_: Any) -> MetaAggregate[Aggregate]:
         """
         Configures aggregate class definition.
         """
+
+        # Avoid processing dataclass twice. This avoids dataclasses.Field(init=False)
+        # attributes being reduced to annotation only and then appearing in __init__
+        # method signature when class is reprocessed, and other similar problems.
+        _ensure_idempotent_dataclass(module_name=args[2]["__module__"])
+
         try:
             class_annotations = args[2]["__annotations__"]
         except KeyError:
@@ -939,8 +972,8 @@ class MetaAggregate(type, Generic[TAggregate]):
             else:
                 annotations_mention_id = True
         aggregate_cls = type.__new__(cls, *args)
-        if class_annotations:
-            aggregate_cls = dataclass(eq=False, repr=False)(aggregate_cls)
+        if class_annotations or any(dataclasses.is_dataclass(base) for base in args[1]):
+            aggregate_cls = dataclasses.dataclass(eq=False, repr=False)(aggregate_cls)
         if annotations_mention_id:
             _annotations_mention_id.add(aggregate_cls)
         return aggregate_cls
@@ -957,7 +990,7 @@ class MetaAggregate(type, Generic[TAggregate]):
 
         # Identify or define a base event class for this aggregate.
         base_event_name = "Event"
-        base_event_cls: Type[CanMutateAggregate]
+        base_event_cls: type[CanMutateAggregate]
         try:
             base_event_cls = cls.__dict__[base_event_name]
         except KeyError:
@@ -967,7 +1000,7 @@ class MetaAggregate(type, Generic[TAggregate]):
             setattr(cls, base_event_name, base_event_cls)
 
         # Make sure all events defined on aggregate subclass the base event class.
-        created_event_classes: Dict[str, Type[CanInitAggregate]] = {}
+        created_event_classes: dict[str, type[CanInitAggregate]] = {}
         for name, value in tuple(cls.__dict__.items()):
             if name == base_event_name:
                 # Don't subclass the base event class again.
@@ -987,7 +1020,7 @@ class MetaAggregate(type, Generic[TAggregate]):
                 created_event_classes[name] = value
 
         # Disallow using both '_created_event_class' and 'created_event_name'.
-        created_event_class: Type[CanInitAggregate] | None = cls.__dict__.get(
+        created_event_class: type[CanInitAggregate] | None = cls.__dict__.get(
             "_created_event_class"
         )
         if created_event_class and created_event_name:
@@ -1015,7 +1048,7 @@ class MetaAggregate(type, Generic[TAggregate]):
             # Does the decorator specify a "created" event class?
             if init_decorator.given_event_cls:
                 created_event_class = cast(
-                    Type[CanInitAggregate], init_decorator.given_event_cls
+                    type[CanInitAggregate], init_decorator.given_event_cls
                 )
             # Does the decorator specify a "created" event name?
             elif init_decorator.event_cls_name:
@@ -1093,11 +1126,11 @@ class MetaAggregate(type, Generic[TAggregate]):
             # Define a "created" event class for this aggregate.
             if issubclass(base_created_event_cls, base_event_cls):
                 # Don't subclass from base event class twice.
-                bases: Tuple[Type[CanMutateAggregate], ...] = (base_created_event_cls,)
+                bases: tuple[type[CanMutateAggregate], ...] = (base_created_event_cls,)
             else:
                 bases = (base_created_event_cls, base_event_cls)
             created_event_class = cast(
-                Type[CanInitAggregate],
+                type[CanInitAggregate],
                 cls._define_event_class(
                     created_event_name,
                     bases,
@@ -1160,7 +1193,7 @@ class MetaAggregate(type, Generic[TAggregate]):
 
                     # Define event class as subclass of given class.
                     given_subclass = cast(
-                        Type[CanMutateAggregate],
+                        type[CanMutateAggregate],
                         getattr(cls, event_decorator.given_event_cls.__name__),
                     )
                     event_cls = cls._define_event_class(
@@ -1194,7 +1227,7 @@ class MetaAggregate(type, Generic[TAggregate]):
 
                 # Remember which event class to trigger.
                 decorated_event_classes[event_decorator] = cast(
-                    Type[MetaAggregate.DecoratedEvent], event_cls
+                    type[MetaAggregate.DecoratedEvent], event_cls
                 )
 
         # Check any create_id method defined on this class is static or class method.
@@ -1208,7 +1241,7 @@ class MetaAggregate(type, Generic[TAggregate]):
             raise TypeError(msg)
 
         # Get the parameters of the create_id method that will be used by this class.
-        cls._create_id_param_names: List[str] = []
+        cls._create_id_param_names: list[str] = []
         for name, param in inspect.signature(cls.create_id).parameters.items():
             if param.kind in [param.KEYWORD_ONLY, param.POSITIONAL_OR_KEYWORD]:
                 cls._create_id_param_names.append(name)
@@ -1230,9 +1263,9 @@ class MetaAggregate(type, Generic[TAggregate]):
     def _define_event_class(
         cls,
         name: str,
-        bases: Tuple[Type[CanMutateAggregate], ...],
+        bases: tuple[type[CanMutateAggregate], ...],
         apply_method: CommandMethod | None,
-    ) -> Type[CanMutateAggregate]:
+    ) -> type[CanMutateAggregate]:
         # Define annotations for the event class (specs the init method).
         annotations = {}
         if apply_method is not None:
@@ -1256,7 +1289,7 @@ class MetaAggregate(type, Generic[TAggregate]):
         }
 
         # Create the event class object.
-        return cast(Type[CanMutateAggregate], type(name, bases, event_cls_dict))
+        return cast(type[CanMutateAggregate], type(name, bases, event_cls_dict))
 
     def __call__(
         cls: MetaAggregate[TAggregate], *args: Any, **kwargs: Any
@@ -1286,7 +1319,7 @@ class MetaAggregate(type, Generic[TAggregate]):
 
     def _create(
         cls: MetaAggregate[TAggregate],
-        event_class: Type[CanInitAggregate],
+        event_class: type[CanInitAggregate],
         **kwargs: Any,
     ) -> TAggregate:
         raise NotImplementedError  # pragma: no cover
@@ -1308,8 +1341,8 @@ class Aggregate(metaclass=MetaAggregate):
 
     @classmethod
     def _create(
-        cls: Type[TAggregate],
-        event_class: Type[CanInitAggregate],
+        cls: type[TAggregate],
+        event_class: type[CanInitAggregate],
         *,
         id: UUID | None = None,  # noqa: A002
         **kwargs: Any,
@@ -1359,7 +1392,7 @@ class Aggregate(metaclass=MetaAggregate):
         self._version = originator_version
         self._created_on = timestamp
         self._modified_on = timestamp
-        self._pending_events: List[CanMutateAggregate] = []
+        self._pending_events: list[CanMutateAggregate] = []
 
     @property
     def id(self) -> UUID:
@@ -1398,7 +1431,7 @@ class Aggregate(metaclass=MetaAggregate):
         self._modified_on = modified_on
 
     @property
-    def pending_events(self) -> List[CanMutateAggregate]:
+    def pending_events(self) -> list[CanMutateAggregate]:
         """
         A list of pending events.
         """
@@ -1423,7 +1456,7 @@ class Aggregate(metaclass=MetaAggregate):
 
     def trigger_event(
         self,
-        event_class: Type[CanMutateAggregate],
+        event_class: type[CanMutateAggregate],
         **kwargs: Any,
     ) -> None:
         """
@@ -1480,7 +1513,7 @@ def aggregate(
     cls: Any | None = None,
     *,
     created_event_name: str = "",
-) -> Type[Aggregate] | Callable[[Any], Type[Aggregate]]:
+) -> type[Aggregate] | Callable[[Any], type[Aggregate]]:
     """
     Converts the class that was passed in to inherit from Aggregate.
 
@@ -1498,7 +1531,7 @@ def aggregate(
             pass
     """
 
-    def decorator(cls_: Any) -> Type[Aggregate]:
+    def decorator(cls_: Any) -> type[Aggregate]:
         if issubclass(cls_, Aggregate):
             msg = f"{cls_.__qualname__} is already an Aggregate"
             raise TypeError(msg)
@@ -1553,7 +1586,7 @@ class VersionError(OriginatorVersionError):
 
 class SnapshotProtocol(DomainEventProtocol, Protocol):
     @property
-    def state(self) -> Dict[str, Any]:
+    def state(self) -> dict[str, Any]:
         """
         Snapshots have a read-only 'state'.
         """
@@ -1575,7 +1608,7 @@ class CanSnapshotAggregate(HasOriginatorIDVersion, CanCreateTimestamp):
 
     @classmethod
     def take(
-        cls: Type[TCanSnapshotAggregate],
+        cls: type[TCanSnapshotAggregate],
         aggregate: MutableOrImmutableAggregate,
     ) -> TCanSnapshotAggregate:
         """
@@ -1601,7 +1634,7 @@ class CanSnapshotAggregate(HasOriginatorIDVersion, CanCreateTimestamp):
         """
         Reconstructs the snapshotted :class:`Aggregate` object.
         """
-        cls = cast(Type[Aggregate], resolve_topic(self.topic))
+        cls = cast(type[Aggregate], resolve_topic(self.topic))
         aggregate_state = dict(self.state)
         from_version = aggregate_state.pop("class_version", 1)
         class_version = getattr(cls, "class_version", 1)
@@ -1634,4 +1667,4 @@ class Snapshot(CanSnapshotAggregate, DomainEvent):
     """
 
     topic: str
-    state: Dict[str, Any]
+    state: dict[str, Any]

eventsourcing/interface.py

@@ -3,12 +3,15 @@ from __future__ import annotations
 import json
 from abc import ABC, abstractmethod
 from base64 import b64decode, b64encode
-from typing import Generic, List, Sequence
+from typing import TYPE_CHECKING, Generic
 from uuid import UUID
 
 from eventsourcing.application import NotificationLog, Section, TApplication
 from eventsourcing.persistence import Notification
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 class NotificationLogInterface(ABC):
     """
@@ -142,7 +145,7 @@ class NotificationLogJSONClient(NotificationLog):
         topics: Sequence[str] = (),
         *,
         inclusive_of_start: bool = True,
-    ) -> List[Notification]:
+    ) -> list[Notification]:
         """
         Returns a selection of
         :class:`~eventsourcing.persistence.Notification` objects