eventsourcing 9.2.22__py3-none-any.whl → 9.3.0__py3-none-any.whl

eventsourcing/domain.py

@@ -2,34 +2,28 @@ from __future__ import annotations
 
 import inspect
 import os
-import sys
 from dataclasses import dataclass
 from datetime import datetime, tzinfo
 from functools import lru_cache
 from types import FunctionType, WrapperDescriptorType
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Dict,
     Generic,
     Iterable,
     List,
-    Optional,
+    Protocol,
     Sequence,
-    Set,
     Tuple,
     Type,
     TypeVar,
     Union,
     cast,
     overload,
+    runtime_checkable,
 )
-
-if sys.version_info >= (3, 8):  # pragma: no cover
-    from typing import Protocol, runtime_checkable
-else:  # pragma: no cover
-    from typing_extensions import Protocol, runtime_checkable
-
 from uuid import UUID, uuid4
 
 from eventsourcing.utils import get_method_name, get_topic, resolve_topic
@@ -150,8 +144,8 @@ class CanMutateProtocol(DomainEventProtocol, Protocol[TMutableOrImmutableAggrega
     """
 
     def mutate(
-        self, aggregate: Optional[TMutableOrImmutableAggregate]
-    ) -> Optional[TMutableOrImmutableAggregate]:
+        self, aggregate: TMutableOrImmutableAggregate | None
+    ) -> TMutableOrImmutableAggregate | None:
         """
         Evolves the state of the given aggregate, either by
         returning the given aggregate instance with modified attributes
@@ -203,7 +197,7 @@ class CanMutateAggregate(HasOriginatorIDVersion, CanCreateTimestamp):
     timestamp: datetime
     """Timezone-aware :class:`datetime` object representing when an event occurred."""
 
-    def mutate(self, aggregate: Optional[TAggregate]) -> Optional[TAggregate]:
+    def mutate(self, aggregate: TAggregate | None) -> TAggregate | None:
         """
         Validates and adjusted the attributes of the given ``aggregate`` argument. The
         argument is typed as ``Optional`` but the value is expected to be not ``None``.
@@ -266,7 +260,7 @@ class CanInitAggregate(CanMutateAggregate):
     originator_topic: str
     """String describing the path to an aggregate class."""
 
-    def mutate(self, aggregate: Optional[TAggregate]) -> Optional[TAggregate]:
+    def mutate(self, aggregate: TAggregate | None) -> TAggregate | None:
         """
         Constructs an aggregate instance according to the attributes of an event.
 
@@ -278,31 +272,34 @@ class CanInitAggregate(CanMutateAggregate):
         # Resolve originator topic.
         aggregate_class: Type[TAggregate] = resolve_topic(self.originator_topic)
 
-        # Construct and return aggregate object.
+        # Construct an aggregate object (a "shell" of the correct object type).
         agg = aggregate_class.__new__(aggregate_class)
 
-        # Separate the base class keywords arguments.
+        # Pick out event attributes for the aggregate base class init method.
         base_kwargs = _filter_kwargs_for_method_params(
             self.__dict__, type(agg).__base_init__
         )
 
-        # Call the base class init method.
+        # Call the base class init method (so we don't need to always write
+        # a call to super().__init__() in every aggregate __init__() method).
         agg.__base_init__(**base_kwargs)
 
-        # Select values that aren't mentioned in the method signature.
+        # Pick out event attributes for aggregate subclass class init method.
         init_kwargs = _filter_kwargs_for_method_params(
             self.__dict__, type(agg).__init__
         )
 
-        # Provide the id, if the init method expects it.
+        # Provide the aggregate id, if the aggregate subclass init method expects it.
         if aggregate_class in _init_mentions_id:
             init_kwargs["id"] = self.__dict__["originator_id"]
 
-        # Call the aggregate class init method.
+        # Call the aggregate subclass class init method.
         agg.__init__(**init_kwargs)  # type: ignore
 
+        # Call the event apply method (alternative to using __init__())
         self.apply(agg)
 
+        # Return the constructed and initialised aggregate object.
         return agg
 
 
@@ -384,36 +381,38 @@ def _filter_kwargs_for_method_params(
 
 
 @lru_cache(maxsize=None)
-def _spec_filter_kwargs_for_method_params(method: Callable[..., Any]) -> Set[str]:
+def _spec_filter_kwargs_for_method_params(method: Callable[..., Any]) -> set[str]:
     method_signature = inspect.signature(method)
     return set(method_signature.parameters)
 
 
-EventSpecType = Union[str, Type[CanMutateAggregate]]
+if TYPE_CHECKING:  # pragma: nocover
+    EventSpecType = Union[str, Type[CanMutateAggregate]]
+
 CommandMethod = Callable[..., None]
 DecoratedObjType = Union[CommandMethod, property]
 TDecoratedObjType = TypeVar("TDecoratedObjType", bound=DecoratedObjType)
-InjectEventType = bool
 
 
 class CommandMethodDecorator:
     def __init__(
         self,
-        event_spec: Optional[EventSpecType],
+        event_spec: EventSpecType | None,
         decorated_obj: DecoratedObjType,
     ):
         self.is_name_inferred_from_method = False
-        self.given_event_cls: Optional[Type[CanMutateAggregate]] = None
-        self.event_cls_name: Optional[str] = None
-        self.decorated_property: Optional[property] = 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
-        self.property_setter_arg_name: Optional[str] = None
-        self.decorated_method: Union[FunctionType, WrapperDescriptorType]
+        self.property_setter_arg_name: str | None = None
+        self.decorated_method: FunctionType | WrapperDescriptorType
 
         # Event name has been specified.
         if isinstance(event_spec, str):
             if event_spec == "":
-                raise ValueError("Can't use empty string as name of event class")
+                msg = "Can't use empty string as name of event class"
+                raise ValueError(msg)
             self.event_cls_name = event_spec
 
         # Event class has been specified.
@@ -422,7 +421,8 @@ class CommandMethodDecorator:
         ):
             if event_spec in given_event_classes:
                 name = event_spec.__name__
-                raise TypeError(f"{name} event class used in more than one decorator")
+                msg = f"{name} event class used in more than one decorator"
+                raise TypeError(msg)
             self.given_event_cls = event_spec
             given_event_classes.add(event_spec)
 
@@ -432,9 +432,8 @@ class CommandMethodDecorator:
             if decorated_obj.fset is None:
                 assert decorated_obj.fget, "Property has no getter"
                 method_name = decorated_obj.fget.__name__
-                raise TypeError(
-                    f"@event can't decorate {method_name}() property getter"
-                )
+                msg = f"@event can't decorate {method_name}() property getter"
+                raise TypeError(msg)
 
             # Remember we are decorating a property.
             self.decorated_property = decorated_obj
@@ -447,9 +446,8 @@ class CommandMethodDecorator:
             # Disallow deriving event class names from property names.
             if not self.given_event_cls and not self.event_cls_name:
                 method_name = self.decorated_method.__name__
-                raise TypeError(
-                    f"@event on {method_name}() setter requires event name or class"
-                )
+                msg = f"@event on {method_name}() setter requires event name or class"
+                raise TypeError(msg)
 
             # Remember the name of the second setter arg.
             setter_arg_names = list(inspect.signature(self.decorated_method).parameters)
@@ -472,7 +470,8 @@ class CommandMethodDecorator:
 
         # Disallow decorating other types of object.
         else:
-            raise TypeError(f"{decorated_obj} is not a function or property")
+            msg = f"{decorated_obj} is not a function or property"
+            raise TypeError(msg)
 
         # Disallow using methods with variable params to define event class.
         if self.event_cls_name:
@@ -496,7 +495,7 @@ class CommandMethodDecorator:
     @overload
     def __get__(
         self, instance: None, owner: MetaAggregate[Aggregate]
-    ) -> Union[UnboundCommandMethodDecorator, property]:
+    ) -> UnboundCommandMethodDecorator | property:
         """
         Descriptor protocol for getting decorated method or property on class object.
         """
@@ -504,16 +503,14 @@ class CommandMethodDecorator:
     @overload
     def __get__(
         self, instance: Aggregate, owner: MetaAggregate[Aggregate]
-    ) -> Union[BoundCommandMethodDecorator, Any]:
+    ) -> BoundCommandMethodDecorator | Any:
         """
         Descriptor protocol for getting decorated method or property on instance object.
         """
 
     def __get__(
-        self, instance: Optional[Aggregate], owner: MetaAggregate[Aggregate]
-    ) -> Union[
-        BoundCommandMethodDecorator, UnboundCommandMethodDecorator, property, Any
-    ]:
+        self, instance: Aggregate | None, owner: MetaAggregate[Aggregate]
+    ) -> BoundCommandMethodDecorator | UnboundCommandMethodDecorator | property | Any:
         """
         Descriptor protocol for getting decorated method or property.
         """
@@ -522,12 +519,11 @@ class CommandMethodDecorator:
             return self.decorated_property.__get__(instance, owner)
 
         # Return a "bound" command method decorator if we have an instance.
-        elif instance:
+        if instance:
             return BoundCommandMethodDecorator(self, instance)
 
         # Return an "unbound" command method decorator if we have no instance.
-        else:
-            return UnboundCommandMethodDecorator(self)
+        return UnboundCommandMethodDecorator(self)
 
     def __set__(self, instance: Aggregate, value: Any) -> None:
         """
@@ -566,8 +562,8 @@ def event(
 
 
 def event(
-    arg: Optional[Union[EventSpecType, TDecoratedObjType]] = None,
-) -> Union[TDecoratedObjType, Callable[[TDecoratedObjType], TDecoratedObjType]]:
+    arg: EventSpecType | TDecoratedObjType | None = None,
+) -> TDecoratedObjType | Callable[[TDecoratedObjType], TDecoratedObjType]:
     """
     Event-triggering decorator for aggregate command methods and property setters.
 
@@ -627,7 +623,7 @@ def event(
             Callable[[TDecoratedObjType], TDecoratedObjType], command_method_decorator
         )
 
-    elif (
+    if (
         arg is None
         or isinstance(arg, str)
         or isinstance(arg, type)
@@ -646,11 +642,11 @@ def event(
 
         return create_command_method_decorator
 
-    else:
-        raise TypeError(
-            f"{arg} is not a str, function, property, or subclass of "
-            f"{CanMutateAggregate.__name__}"
-        )
+    msg = (
+        f"{arg} is not a str, function, property, or subclass of "
+        f"{CanMutateAggregate.__name__}"
+    )
+    raise TypeError(msg)
 
 
 triggers = event
@@ -676,7 +672,8 @@ class UnboundCommandMethodDecorator:
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         # Expect first argument is an aggregate instance.
         if len(args) < 1 or not isinstance(args[0], Aggregate):
-            raise TypeError("Expected aggregate as first argument")
+            msg = "Expected aggregate as first argument"
+            raise TypeError(msg)
         aggregate: Aggregate = args[0]
         assert isinstance(aggregate, Aggregate)
         BoundCommandMethodDecorator(self.event_decorator, aggregate)(
@@ -716,7 +713,7 @@ class BoundCommandMethodDecorator:
         self.trigger(*args, **kwargs)
 
 
-given_event_classes: Set[type] = set()
+given_event_classes: set[type] = set()
 decorated_methods: Dict[type, CommandMethod] = {}
 aggregate_has_many_created_event_classes: Dict[type, List[str]] = {}
 
@@ -729,24 +726,23 @@ decorated_event_classes: Dict[
 def _check_no_variable_params(method: FunctionType) -> None:
     for param in inspect.signature(method).parameters.values():
         if param.kind is param.VAR_POSITIONAL:
-            raise TypeError(
-                f"*{param.name} not supported by decorator on {method.__name__}()"
-            )
-            # Todo: Support VAR_POSITIONAL?
+            msg = f"*{param.name} not supported by decorator on {method.__name__}()"
+            raise TypeError(msg)
+            # TODO: Support VAR_POSITIONAL?
             # annotations["__star_args__"] = "typing.Any"
 
         if param.kind is param.VAR_KEYWORD:
-            # Todo: Support VAR_KEYWORD?
+            # TODO: Support VAR_KEYWORD?
             # annotations["__star_kwargs__"] = "typing.Any"
-            raise TypeError(
-                f"**{param.name} not supported by decorator on {method.__name__}()"
-            )
+            msg = f"**{param.name} not supported by decorator on {method.__name__}()"
+            raise TypeError(msg)
 
 
 def _coerce_args_to_kwargs(
-    method: Union[FunctionType, WrapperDescriptorType],
+    method: FunctionType | WrapperDescriptorType,
     args: Iterable[Any],
     kwargs: Dict[str, Any],
+    *,
     expects_id: bool = False,
 ) -> Dict[str, Any]:
     assert isinstance(method, (FunctionType, WrapperDescriptorType))
@@ -769,9 +765,10 @@ def _coerce_args_to_kwargs(
 
 @lru_cache(maxsize=None)
 def _spec_coerce_args_to_kwargs(
-    method: Union[FunctionType, WrapperDescriptorType],
+    method: FunctionType | WrapperDescriptorType,
     len_args: int,
     kwargs_keys: Tuple[str],
+    *,
     expects_id: bool,
 ) -> Tuple[Tuple[Tuple[int, str], ...], Tuple[Tuple[str, Any], ...]]:
     method_signature = inspect.signature(method)
@@ -800,9 +797,8 @@ def _spec_coerce_args_to_kwargs(
     method_name = get_method_name(method)
     for name in kwargs_keys:
         if name not in required_keyword_only and name not in positional_names:
-            raise TypeError(
-                f"{method_name}() got an unexpected " f"keyword argument '{name}'"
-            )
+            msg = f"{method_name}() got an unexpected keyword argument '{name}'"
+            raise TypeError(msg)
     if len_args > len(positional_names):
         msg = (
             f"{method_name}() takes {len(positional_names) + 1} "
@@ -829,21 +825,18 @@ def _spec_coerce_args_to_kwargs(
         if counter + 1 > len_args:
             break
         if name in kwargs_keys:
-            raise TypeError(
-                f"{method_name}() got multiple values for argument '{name}'"
-            )
-        else:
-            args_names.append(name)
-            counter += 1
-    missing_keyword_only_arguments = []
-    for name in required_keyword_only:
-        if name not in kwargs_keys:
-            missing_keyword_only_arguments.append(name)
+            msg = f"{method_name}() got multiple values for argument '{name}'"
+            raise TypeError(msg)
+        args_names.append(name)
+        counter += 1
+    missing_keyword_only_arguments = [
+        name for name in required_keyword_only if name not in kwargs_keys
+    ]
     if missing_keyword_only_arguments:
         missing_names = [f"'{name}'" for name in missing_keyword_only_arguments]
         msg = (
             f"{method_name}() missing {len(missing_names)} "
-            f"required keyword-only argument"
+            "required keyword-only argument"
             f"{'' if len(missing_names) == 1 else 's'}: "
         )
         _raise_missing_names_type_error(missing_names, msg)
@@ -865,10 +858,8 @@ def _raise_missing_names_type_error(missing_names: List[str], msg: str) -> None:
     raise TypeError(msg)
 
 
-_TT = TypeVar("_TT", bound="type")
-
-_annotations_mention_id: Set[MetaAggregate[Aggregate]] = set()
-_init_mentions_id: Set[MetaAggregate[Aggregate]] = set()
+_annotations_mention_id: set[MetaAggregate[Aggregate]] = set()
+_init_mentions_id: set[MetaAggregate[Aggregate]] = set()
 
 
 class MetaAggregate(type, Generic[TAggregate]):
@@ -905,7 +896,7 @@ class MetaAggregate(type, Generic[TAggregate]):
 
     _created_event_class: Type[CanInitAggregate]
 
-    def __new__(cls, *args: Any, **kwargs: Any) -> MetaAggregate[Aggregate]:
+    def __new__(cls, *args: Any, **_: Any) -> MetaAggregate[Aggregate]:
         """
         Configures aggregate class definition.
         """
@@ -950,6 +941,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]] = {}
         for name, value in tuple(cls.__dict__.items()):
             if name == base_event_name:
                 # Don't subclass the base event class again.
@@ -957,36 +949,26 @@ class MetaAggregate(type, Generic[TAggregate]):
             if name.lower() == name:
                 # Don't subclass lowercase named attributes that have classes.
                 continue
-            if isinstance(value, type) and issubclass(value, AggregateEvent):
-                if not issubclass(value, base_event_cls):
-                    sub_class = cls._define_event_class(
-                        name, (value, base_event_cls), None
-                    )
-                    setattr(cls, name, sub_class)
-
-        # Identify or define the aggregate's "created" event class.
-        created_event_class: Optional[Type[CanInitAggregate]] = None
-
-        # Has the "created" event class been indicated with '_created_event_class'.
-        if "_created_event_class" in cls.__dict__:
-            created_event_class = cls.__dict__["_created_event_class"]
-            if isinstance(created_event_class, type) and issubclass(
-                created_event_class, CanInitAggregate
+            if (
+                isinstance(value, type)
+                and issubclass(value, AggregateEvent)
+                and not issubclass(value, base_event_cls)
             ):
-                # We just subclassed the event classes, so reassign this.
-                created_event_class = getattr(cls, created_event_class.__name__)
-                assert created_event_class
-                cls._created_event_class = created_event_class
-            else:
-                raise TypeError(
-                    f"{created_event_class} not subclass of {CanInitAggregate.__name__}"
-                )
+                sub_class = cls._define_event_class(name, (value, base_event_cls), None)
+                setattr(cls, name, sub_class)
+        for name, value in tuple(cls.__dict__.items()):
+            if isinstance(value, type) and issubclass(value, CanInitAggregate):
+                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"
+        )
         if created_event_class and created_event_name:
-            raise TypeError(
-                "Can't use both '_created_event_class' and 'created_event_name'"
-            )
+            msg = "Can't use both '_created_event_class' and 'created_event_name'"
+            raise TypeError(msg)
+
+        # Identify or define the aggregate's "created" event class.
 
         # Is the init method decorated with a CommandMethodDecorator?
         if isinstance(cls.__dict__.get("__init__"), CommandMethodDecorator):
@@ -995,112 +977,119 @@ class MetaAggregate(type, Generic[TAggregate]):
             # Set the original method on the class (un-decorate __init__).
             cls.__init__ = init_decorator.decorated_method  # type: ignore
 
-            # Disallow using both 'created_event_name' and '_created_event_class'.
+            # Disallow using both 'created_event_name' and decorator on __init__.
             if created_event_name:
-                raise TypeError(
-                    "Can't use both 'created_event_name' and decorator on __init__"
-                )
-            elif created_event_class:
-                raise TypeError(
-                    "Can't use both '_created_event_class' and decorator on __init__"
-                )
-
-            # Does the decorator specify a "create" event class?
+                msg = "Can't use both 'created_event_name' and decorator on __init__"
+                raise TypeError(msg)
+            # Disallow using both '_created_event_class' and decorator on __init__.
+            if created_event_class:
+                msg = "Can't use both '_created_event_class' and decorator on __init__"
+                raise TypeError(msg)
+
+            # Does the decorator specify a "created" event class?
             if init_decorator.given_event_cls:
-                created_event_class = getattr(
-                    cls, init_decorator.given_event_cls.__name__
+                created_event_class = cast(
+                    Type[CanInitAggregate], init_decorator.given_event_cls
                 )
-                if isinstance(created_event_class, type) and issubclass(
-                    created_event_class, CanInitAggregate
-                ):
-                    assert created_event_class
-                    cls._created_event_class = created_event_class
-                else:
-                    raise TypeError(
-                        f"{created_event_class} not subclass of "
-                        f"{CanInitAggregate.__name__}"
-                    )
-
             # Does the decorator specify a "created" event name?
             elif init_decorator.event_cls_name:
                 created_event_name = init_decorator.event_cls_name
 
             # Disallow using decorator on __init__ without event spec.
             else:
-                raise TypeError(
-                    "Decorator on __init__ has neither event name nor class"
-                )
+                msg = "Decorator on __init__ has neither event name nor class"
+                raise TypeError(msg)
 
-        # Todo: Write a test to cover this when "Created" class is explicitly defined.
+        # TODO: Write a test to cover this when "Created" class is explicitly defined.
         # Check if init mentions ID.
         for param_name in inspect.signature(cls.__init__).parameters:  # type: ignore
             if param_name == "id":
                 _init_mentions_id.add(cls)
                 break
 
-        # If no "created" event class has been specified, find or create one.
-        if created_event_class is None:
-            # Discover all the "created" event classes already defined.
-            created_event_classes: Dict[str, Type[AggregateCreated]] = {}
-            for name, value in tuple(cls.__dict__.items()):
-                if isinstance(value, type) and issubclass(value, AggregateCreated):
-                    created_event_classes[name] = value
-
-            # Is a "created" event class already defined that matches the name?
-            if created_event_name in created_event_classes:
-                cls._created_event_class = created_event_classes[created_event_name]
-
-            # If there is only one class defined, and we have no name, use it.
-            elif len(created_event_classes) == 1 and not created_event_name:
-                cls._created_event_class = next(iter(created_event_classes.values()))
-
-            # If there are no "created" event classes already defined, or a name is
-            # specified that hasn't matched, then define a "created" event class.
-            elif len(created_event_classes) == 0 or created_event_name:
-                # If no "created" event name has been specified, use default name.
-                if not created_event_name:
-                    # This is safe because len(created_event_classes) == 0.
-                    created_event_name = "Created"
-
-                # Disallow init method from having variable params if
-                # we are using it to define a "created" event class.
+        if created_event_class:
+            # Check specified "created" event class can init aggregate.
+            if not issubclass(created_event_class, CanInitAggregate):
+                msg = (
+                    f"{created_event_class} not subclass of {CanInitAggregate.__name__}"
+                )
+                raise TypeError(msg)
+
+            for sub_class in created_event_classes.values():
+                if issubclass(sub_class, created_event_class):
+                    # We just subclassed the created event class, so reassign it.
+                    created_event_class = sub_class
+
+        # Is a "created" event class already defined that matches the name?
+        elif created_event_name and created_event_name in created_event_classes:
+            created_event_class = created_event_classes[created_event_name]
+
+        # If there is only one class defined, then use it.
+        elif len(created_event_classes) == 1 and not created_event_name:
+            created_event_class = next(iter(created_event_classes.values()))
+
+        # If there are no "created" event classes already defined, or a name is
+        # specified that hasn't matched, then define a "created" event class.
+        elif len(created_event_classes) == 0 or created_event_name:
+
+            # Decide the base classes for the new "created" event class.
+            if created_event_name and len(created_event_classes) == 1:
+                base_created_event_cls = next(iter(created_event_classes.values()))
+            else:
+                for base_cls in cls.__mro__:
+                    if base_cls is cls:
+                        continue
+                    base_created_event_cls = base_cls.__dict__.get(
+                        "_created_event_class",
+                        base_cls.__dict__.get("Created"),
+                    )
+                    if base_created_event_cls:
+                        break
+                else:  # pragma: no cover
+                    msg = "Can't decide base class for new 'created' event class"
+                    raise TypeError(msg)
+
+            if not created_event_name:
+                created_event_name = base_created_event_cls.__name__
+
+            # Disallow init method from having variable params if
+            # we are using it to define a "created" event class.
+            try:
+                init_method = cls.__dict__["__init__"]
+            except KeyError:
+                init_method = None
+            else:
                 try:
-                    init_method = cls.__dict__["__init__"]
-                except KeyError:
-                    init_method = None
-                else:
-                    try:
-                        _check_no_variable_params(init_method)
-                    except TypeError:
-                        raise
-
-                # Define a "created" event class for this aggregate.
-                if issubclass(cls.Created, base_event_cls):
-                    # Don't subclass from base event class twice.
-                    bases: Tuple[Type[CanMutateAggregate], ...] = (cls.Created,)
-                else:
-                    bases = (cls.Created, base_event_cls)
-                event_cls = cls._define_event_class(
+                    _check_no_variable_params(init_method)
+                except TypeError:
+                    raise
+
+            # 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,)
+            else:
+                bases = (base_created_event_cls, base_event_cls)
+            created_event_class = cast(
+                Type[CanInitAggregate],
+                cls._define_event_class(
                     created_event_name,
                     bases,
                     init_method,
-                )
-
-                # Set the event class as an attribute of the aggregate class.
-                setattr(cls, created_event_name, event_cls)
-
-                # Remember which is the "created" event class.
-                cls._created_event_class = cast(Type[AggregateCreated], event_cls)
+                ),
+            )
+            # Set the event class as an attribute of the aggregate class.
+            setattr(cls, created_event_name, created_event_class)
 
+        if created_event_class:
+            cls._created_event_class = created_event_class
+        else:
             # Prepare to disallow ambiguity of choice between created event classes.
-            else:
-                aggregate_has_many_created_event_classes[cls] = list(
-                    created_event_classes
-                )
+            aggregate_has_many_created_event_classes[cls] = list(created_event_classes)
 
         # Prepare the subsequent event classes.
         for attr_name, attr_value in tuple(cls.__dict__.items()):
-            event_decorator: Optional[CommandMethodDecorator] = None
+            event_decorator: CommandMethodDecorator | None = None
 
             if isinstance(attr_value, CommandMethodDecorator):
                 event_decorator = attr_value
@@ -1123,24 +1112,25 @@ class MetaAggregate(type, Generic[TAggregate]):
                         # is a decorated method.
                         continue
                         # Otherwise, it's "x = property(getx, event(setx))".
-                else:
+                elif event_decorator.is_name_inferred_from_method:
                     # This is the "@property.setter \ @event" form. We don't want
                     # event class name inferred from property (not past participle).
-                    if event_decorator.is_name_inferred_from_method:
-                        method_name = event_decorator.decorated_method.__name__
-                        raise TypeError(
-                            f"@event under {method_name}() property setter requires "
-                            f"event class name"
-                        )
+                    method_name = event_decorator.decorated_method.__name__
+                    msg = (
+                        f"@event under {method_name}() property setter requires "
+                        "event class name"
+                    )
+                    raise TypeError(msg)
 
             if event_decorator is not None:
                 if event_decorator.given_event_cls:
                     # Check this is not a "created" event class.
                     if issubclass(event_decorator.given_event_cls, CanInitAggregate):
-                        raise TypeError(
+                        msg = (
                             f"{event_decorator.given_event_cls} "
                             f"is subclass of {CanInitAggregate.__name__}"
                         )
+                        raise TypeError(msg)
 
                     # Define event class as subclass of given class.
                     given_subclass = cast(
@@ -1157,10 +1147,11 @@ class MetaAggregate(type, Generic[TAggregate]):
                     # Check event class isn't already defined.
                     assert event_decorator.event_cls_name
                     if event_decorator.event_cls_name in cls.__dict__:
-                        raise TypeError(
+                        msg = (
                             f"{event_decorator.event_cls_name} "
                             f"event already defined on {cls.__name__}"
                         )
+                        raise TypeError(msg)
 
                     # Define event class from signature of original method.
                     event_cls = cls._define_event_class(
@@ -1181,12 +1172,14 @@ class MetaAggregate(type, Generic[TAggregate]):
                 )
 
         # Check any create_id method defined on this class is static or class method.
-        if "create_id" in cls.__dict__:
-            if not isinstance(cls.__dict__["create_id"], (staticmethod, classmethod)):
-                raise TypeError(
-                    f"{cls.create_id} is not a static or class method: "
-                    f"{type(cls.create_id)}"
-                )
+        if "create_id" in cls.__dict__ and not isinstance(
+            cls.__dict__["create_id"], (staticmethod, classmethod)
+        ):
+            msg = (
+                f"{cls.create_id} is not a static or class method: "
+                f"{type(cls.create_id)}"
+            )
+            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] = []
@@ -1212,7 +1205,7 @@ class MetaAggregate(type, Generic[TAggregate]):
         cls,
         name: str,
         bases: Tuple[Type[CanMutateAggregate], ...],
-        apply_method: Optional[CommandMethod],
+        apply_method: CommandMethod | None,
     ) -> Type[CanMutateAggregate]:
         # Define annotations for the event class (specs the init method).
         annotations = {}
@@ -1229,7 +1222,7 @@ class MetaAggregate(type, Generic[TAggregate]):
                 # Don't override super class annotations, unless no default on param.
                 if param_name not in super_annotations or param.default == param.empty:
                     annotations[param_name] = param.annotation or "typing.Any"
-        event_cls_qualname = ".".join([cls.__qualname__, name])
+        event_cls_qualname = f"{cls.__qualname__}.{name}"
         event_cls_dict = {
             "__annotations__": annotations,
             "__module__": cls.__module__,
@@ -1244,15 +1237,16 @@ class MetaAggregate(type, Generic[TAggregate]):
     ) -> TAggregate:
         try:
             created_event_classes = aggregate_has_many_created_event_classes[cls]
-            raise TypeError(
+            msg = (
                 """Can't decide which of many "created" event classes to use: """
                 f"""'{"', '".join(created_event_classes)}'. Please use class """
                 "arg 'created_event_name' or @event decorator on __init__ method."
             )
+            raise TypeError(msg)
         except KeyError:
             pass
 
-        cls_init: Union[FunctionType, WrapperDescriptorType] = cls.__init__  # type: ignore
+        cls_init: FunctionType | WrapperDescriptorType = cls.__init__  # type: ignore
         kwargs = _coerce_args_to_kwargs(
             cls_init,
             args,
@@ -1269,10 +1263,10 @@ class MetaAggregate(type, Generic[TAggregate]):
         event_class: Type[CanInitAggregate],
         **kwargs: Any,
     ) -> TAggregate:
-        raise NotImplementedError()  # pragma: no cover
+        raise NotImplementedError  # pragma: no cover
 
     @staticmethod
-    def create_id(**kwargs: Any) -> UUID:
+    def create_id(**_: Any) -> UUID:
         """
         Returns a new aggregate ID.
         """
@@ -1291,7 +1285,7 @@ class Aggregate(metaclass=MetaAggregate):
         cls: Type[TAggregate],
         event_class: Type[CanInitAggregate],
         *,
-        id: Optional[UUID] = None,
+        id: UUID | None = None,  # noqa: A002
         **kwargs: Any,
     ) -> TAggregate:
         """
@@ -1318,7 +1312,7 @@ class Aggregate(metaclass=MetaAggregate):
             created_event = event_class(**kwargs)
         except TypeError as e:
             msg = f"Unable to construct '{event_class.__name__}' event: {e}"
-            raise TypeError(msg)
+            raise TypeError(msg) from None
         # Construct the aggregate object.
         agg = cast(TAggregate, created_event.mutate(None))
 
@@ -1390,7 +1384,7 @@ class Aggregate(metaclass=MetaAggregate):
     class Created(Event, AggregateCreated):
         pass
 
-    def __eq__(self, other: Any) -> bool:
+    def __eq__(self, other: object) -> bool:
         return type(self) is type(other) and self.__dict__ == other.__dict__
 
     def __repr__(self) -> str:
@@ -1427,7 +1421,8 @@ class Aggregate(metaclass=MetaAggregate):
         try:
             new_event = event_class(**kwargs)
         except TypeError as e:
-            raise TypeError(f"Can't construct event {event_class}: {e}")
+            msg = f"Can't construct event {event_class}: {e}"
+            raise TypeError(msg) from None
 
         # Mutate aggregate with domain event.
         new_event.mutate(self)
@@ -1456,10 +1451,10 @@ class Aggregate(metaclass=MetaAggregate):
 
 
 def aggregate(
-    cls: Optional[Any] = None,
+    cls: Any | None = None,
     *,
     created_event_name: str = "",
-) -> Union[Type[Aggregate], Callable[[Any], Type[Aggregate]]]:
+) -> Type[Aggregate] | Callable[[Any], Type[Aggregate]]:
     """
     Converts the class that was passed in to inherit from Aggregate.
 
@@ -1479,13 +1474,14 @@ def aggregate(
 
     def decorator(cls_: Any) -> Type[Aggregate]:
         if issubclass(cls_, Aggregate):
-            raise TypeError(f"{cls_.__qualname__} is already an Aggregate")
+            msg = f"{cls_.__qualname__} is already an Aggregate"
+            raise TypeError(msg)
         bases = cls_.__bases__
         if bases == (object,):
             bases = (Aggregate,)
         else:
             bases += (Aggregate,)
-        cls_dict = dict()
+        cls_dict = {}
         cls_dict.update(cls_.__dict__)
         cls_ = MetaAggregate(
             cls_.__qualname__,
@@ -1498,8 +1494,7 @@ def aggregate(
 
     if cls:
         return decorator(cls)
-    else:
-        return decorator
+    return decorator
 
 
 class OriginatorIDError(EventSourcingError):
@@ -1543,7 +1538,7 @@ class SnapshotProtocol(DomainEventProtocol, Protocol):
         Snapshots have a read-only 'state'.
         """
 
-    # Todo: Improve on this 'Any'.
+    # TODO: Improve on this 'Any'.
     @classmethod
     def take(cls: Any, aggregate: Any) -> Any:
         """
@@ -1574,14 +1569,13 @@ class CanSnapshotAggregate(HasOriginatorIDVersion, CanCreateTimestamp):
             aggregate_state.pop("_id")
             aggregate_state.pop("_version")
             aggregate_state.pop("_pending_events")
-        snapshot = cls(  # type: ignore
+        return cls(  # type: ignore
             originator_id=aggregate.id,
             originator_version=aggregate.version,
             timestamp=cls.create_timestamp(),
             topic=get_topic(type(aggregate)),
             state=aggregate_state,
         )
-        return snapshot
 
     def mutate(self, _: None) -> Aggregate:
         """