eventsourcing 9.4.5__py3-none-any.whl → 9.5.0a0__py3-none-any.whl

eventsourcing/domain.py

@@ -17,6 +17,7 @@ from typing import (
     Callable,
     ClassVar,
     Generic,
+    Optional,
     Protocol,
     TypeVar,
     Union,
@@ -31,6 +32,7 @@ from warnings import warn
 
 from eventsourcing.utils import (
     TopicError,
+    construct_topic,
     get_method_name,
     get_topic,
     register_topic,
@@ -237,35 +239,41 @@ class CanCreateTimestamp:
 TAggregate = TypeVar("TAggregate", bound="BaseAggregate[Any]")
 
 
-class HasOriginatorIDVersion(Generic[TAggregateID_co]):
+class HasOriginatorIDVersion(Generic[TAggregateID]):
     """Declares ``originator_id`` and ``originator_version`` attributes."""
 
-    originator_id: TAggregateID_co
+    originator_id: TAggregateID
     """UUID identifying an aggregate to which the event belongs."""
     originator_version: int
     """Integer identifying the version of the aggregate when the event occurred."""
 
-    type_originator_id: ClassVar[type[Union[UUID, str]]]  # noqa: UP007
+    originator_id_type: ClassVar[Optional[type[Union[UUID, str]]]] = None  # noqa: UP007
 
     def __init_subclass__(cls) -> None:
         cls.find_originator_id_type(HasOriginatorIDVersion)
+        super().__init_subclass__()
 
     @classmethod
     def find_originator_id_type(cls: type, generic_cls: type) -> None:
-        """Store the type argument of TAggregateID_co on the subclass."""
-        for orig_base in cls.__orig_bases__:  # type: ignore[attr-defined]
-            type_originator_id = orig_base.__dict__.get("type_originator_id", "")
-            if type_originator_id in (UUID, str):
-                cls.type_originator_id = type_originator_id  # type: ignore[attr-defined]
-                break
-            if get_origin(orig_base) is generic_cls:
-                type_originator_id = get_args(orig_base)[0]
-                if type_originator_id in (UUID, str):
-                    cls.type_originator_id = type_originator_id  # type: ignore[attr-defined]
-                    break
+        """Store the type argument of TAggregateID on the subclass."""
+        if "originator_id_type" not in cls.__dict__:
+            for orig_base in cls.__orig_bases__:  # type: ignore[attr-defined]
+                if "originator_id_type" in orig_base.__dict__:
+                    cls.originator_id_type = orig_base.__dict__["originator_id_type"]  # type: ignore[attr-defined]
+                elif get_origin(orig_base) is generic_cls:
+                    originator_id_type = get_args(orig_base)[0]
+                    if originator_id_type in (UUID, str):
+                        cls.originator_id_type = originator_id_type  # type: ignore[attr-defined]
+                        break
+                    if originator_id_type is Any:
+                        continue
+                    if isinstance(originator_id_type, TypeVar):
+                        continue
+                    msg = f"Aggregate ID type arg cannot be {originator_id_type}"
+                    raise TypeError(msg)
 
 
-class CanMutateAggregate(HasOriginatorIDVersion[TAggregateID_co], CanCreateTimestamp):
+class CanMutateAggregate(HasOriginatorIDVersion[TAggregateID], CanCreateTimestamp):
     """Implements a :py:func:`~eventsourcing.domain.CanMutateAggregate.mutate`
     method that evolves the state of an aggregate.
     """
@@ -276,6 +284,7 @@ class CanMutateAggregate(HasOriginatorIDVersion[TAggregateID_co], CanCreateTimes
 
     def __init_subclass__(cls) -> None:
         cls.find_originator_id_type(CanMutateAggregate)
+        super().__init_subclass__()
 
     def mutate(self, aggregate: TAggregate | None) -> TAggregate | None:
         """Validates and adjusts the attributes of the given ``aggregate``
@@ -333,7 +342,7 @@ class CanMutateAggregate(HasOriginatorIDVersion[TAggregateID_co], CanCreateTimes
         return self.__dict__
 
 
-class CanInitAggregate(CanMutateAggregate[TAggregateID_co]):
+class CanInitAggregate(CanMutateAggregate[TAggregateID]):
     """Implements a :func:`~eventsourcing.domain.CanMutateAggregate.mutate`
     method that constructs the initial state of an aggregate.
     """
@@ -343,6 +352,7 @@ class CanInitAggregate(CanMutateAggregate[TAggregateID_co]):
 
     def __init_subclass__(cls) -> None:
         cls.find_originator_id_type(CanInitAggregate)
+        super().__init_subclass__()
 
     def mutate(self, aggregate: TAggregate | None) -> TAggregate | None:
         """Constructs an aggregate instance according to the attributes of an event.
@@ -360,7 +370,7 @@ class CanInitAggregate(CanMutateAggregate[TAggregateID_co]):
 
         # Pick out event attributes for the aggregate base class init method.
         self_dict = self._as_dict()
-        base_kwargs = _filter_kwargs_for_method_params(
+        base_kwargs = filter_kwargs_for_method_params(
             self_dict, type(agg).__base_init__
         )
 
@@ -369,7 +379,7 @@ class CanInitAggregate(CanMutateAggregate[TAggregateID_co]):
         agg.__base_init__(**base_kwargs)
 
         # Pick out event attributes for aggregate subclass class init method.
-        init_kwargs = _filter_kwargs_for_method_params(self_dict, type(agg).__init__)
+        init_kwargs = filter_kwargs_for_method_params(self_dict, type(agg).__init__)
 
         # Provide the aggregate id, if the __init__ method expects it.
         if aggregate_class in _init_mentions_id:
@@ -450,7 +460,7 @@ class LogEvent(DomainEvent):
     """
 
 
-def _filter_kwargs_for_method_params(
+def filter_kwargs_for_method_params(
     kwargs: dict[str, Any], method: Callable[..., Any]
 ) -> dict[str, Any]:
     names = _spec_filter_kwargs_for_method_params(method)
@@ -463,8 +473,14 @@ def _spec_filter_kwargs_for_method_params(method: Callable[..., Any]) -> set[str
     return set(method_signature.parameters)
 
 
+class AbstractDCBEvent:
+    pass
+
+
 if TYPE_CHECKING:
-    EventSpecType = Union[str, type[CanMutateAggregate[Any]]]
+    EventSpecType = Union[  # noqa: PYI055
+        str, type[CanMutateAggregate[Any]], type[AbstractDCBEvent]
+    ]
 
 CallableType = Callable[..., None]
 DecoratableType = Union[CallableType, property]
@@ -479,7 +495,9 @@ class CommandMethodDecorator:
         event_topic: str | None = None,
     ):
         self.is_name_inferred_from_method = False
-        self.given_event_cls: type[CanMutateAggregate[Any]] | None = None
+        self.given_event_cls: (
+            type[CanMutateAggregate[Any] | AbstractDCBEvent] | None
+        ) = None
         self.event_cls_name: str | None = None
         self.decorated_property: property | None = None
         self.is_property_setter = False
@@ -496,9 +514,13 @@ class CommandMethodDecorator:
 
         # Event class has been specified.
         elif isinstance(event_spec, type) and issubclass(
-            event_spec, CanMutateAggregate
+            event_spec, (CanMutateAggregate, AbstractDCBEvent)
         ):
-            if event_spec in _given_event_classes:
+            # Guard against associating more than one method body with any given class.
+            if (
+                issubclass(event_spec, CanMutateAggregate)
+                and event_spec in _given_event_classes
+            ):
                 name = event_spec.__name__
                 msg = f"{name} event class used in more than one decorator"
                 raise TypeError(msg)
@@ -542,6 +564,10 @@ class CommandMethodDecorator:
             # Remember the decorated obj as the decorated method.
             self.decorated_func = decorated_obj
 
+            if self.decorated_func.__name__ == "_":
+                underscore_method_decorators.append(
+                    (construct_topic(self.decorated_func), self)
+                )
             # If necessary, derive an event class name from the method.
             if not self.given_event_cls and not self.event_cls_name:
                 original_method_name = self.decorated_func.__name__
@@ -599,6 +625,10 @@ class CommandMethodDecorator:
         self, instance: BaseAggregate[Any] | None, owner: type[BaseAggregate[Any]]
     ) -> BoundCommandMethodDecorator | UnboundCommandMethodDecorator | property | Any:
         """Descriptor protocol for getting decorated method or property."""
+        if self.decorated_func.__name__ == "_":
+            msg = "Underscore 'non-command' methods cannot be used to trigger events."
+            raise ProgrammingError(msg)
+
         # If we are decorating a property, then delegate to the property's __get__.
         if self.decorated_property:
             return self.decorated_property.__get__(instance, owner)
@@ -611,6 +641,12 @@ class CommandMethodDecorator:
         if instance:
             return BoundCommandMethodDecorator(self, instance)
 
+        if "SPHINX_BUILD" in os.environ:  # pragma: no cover
+            # Sphinx hack: use the original function when sphinx is running so that the
+            # documentation ends up with the correct function signatures.
+            # See 'SPHINX_BUILD' in conf.py.
+            return self.decorated_func
+
         # Return an "unbound" command method decorator if we have no instance.
         return UnboundCommandMethodDecorator(self)
 
@@ -630,7 +666,7 @@ def event(arg: TDecoratableType, /) -> TDecoratableType:
 
 @overload
 def event(
-    arg: type[CanMutateAggregate[Any]], /
+    arg: type[CanMutateAggregate[Any] | AbstractDCBEvent], /
 ) -> Callable[[TDecoratableType], TDecoratableType]:
     """Signature for calling ``@event`` decorator with event class."""
 
@@ -711,7 +747,10 @@ def event(
     if (
         arg is None
         or isinstance(arg, str)
-        or (isinstance(arg, type) and issubclass(arg, CanMutateAggregate))
+        or (
+            isinstance(arg, type)
+            and issubclass(arg, (CanMutateAggregate, AbstractDCBEvent))
+        )
     ):
         event_spec = arg
 
@@ -764,14 +803,22 @@ class UnboundCommandMethodDecorator:
         )
 
 
+class CanTriggerEvent(Protocol):
+    def trigger_event(
+        self,
+        event_class: type[Any],
+        **kwargs: Any,
+    ) -> None:
+        pass  # pragma: no cover
+
+
 class BoundCommandMethodDecorator:
-    """Binds a CommandMethodDecorator with an aggregate instance so calls to
-    decorated command methods can be intercepted and will trigger an event.
+    """Binds a CommandMethodDecorator with an object instance that can trigger
+    events, so that calls to decorated command methods can be intercepted and
+    will trigger a "decorated func caller" event.
     """
 
-    def __init__(
-        self, event_decorator: CommandMethodDecorator, aggregate: BaseAggregate[Any]
-    ):
+    def __init__(self, event_decorator: CommandMethodDecorator, obj: CanTriggerEvent):
         """:param CommandMethodDecorator event_decorator:
         :param Aggregate aggregate:
         """
@@ -781,29 +828,41 @@ class BoundCommandMethodDecorator:
         self.__qualname__ = event_decorator.decorated_func.__qualname__
         self.__annotations__ = event_decorator.decorated_func.__annotations__
         self.__doc__ = event_decorator.decorated_func.__doc__
-        self.aggregate = aggregate
+        self.obj = obj
 
     def trigger(self, *args: Any, **kwargs: Any) -> None:
         kwargs = _coerce_args_to_kwargs(
             self.event_decorator.decorated_func, args, kwargs
         )
-        event_cls = decorator_event_classes[self.event_decorator]
-        kwargs = _filter_kwargs_for_method_params(kwargs, event_cls)
-        self.aggregate.trigger_event(event_cls, **kwargs)
+        try:
+            event_cls = decorated_func_callers[self.event_decorator]
+        except KeyError as e:  # pragma: no cover
+            msg = (
+                f"Event class not registered for event decorator on "
+                f"{self.event_decorator.decorated_func.__qualname__}"
+            )
+            raise KeyError(msg) from e
+        kwargs = filter_kwargs_for_method_params(kwargs, event_cls)
+        assert issubclass(event_cls, AbstractDecoratedFuncCaller), event_cls
+        self.obj.trigger_event(event_cls, **kwargs)
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         self.trigger(*args, **kwargs)
 
 
-class DecoratorEvent(CanMutateAggregate[Any]):
+class AbstractDecoratedFuncCaller:
+    pass
+
+
+class DecoratedFuncCaller(CanMutateAggregate[Any], AbstractDecoratedFuncCaller):
     def apply(self, aggregate: BaseAggregate[Any]) -> None:
         """Applies event to aggregate by calling method decorated by @event."""
         # Identify the function that was decorated.
-        decorated_func = _decorated_funcs[type(self)]
+        decorated_func = decorated_funcs[type(self)]
 
         # Select event attributes mentioned in function signature.
         self_dict = self._as_dict()
-        kwargs = _filter_kwargs_for_method_params(self_dict, decorated_func)
+        kwargs = filter_kwargs_for_method_params(self_dict, decorated_func)
 
         # Call the original method with event attribute values.
         decorated_method = decorated_func.__get__(aggregate, type(aggregate))
@@ -813,12 +872,22 @@ class DecoratorEvent(CanMutateAggregate[Any]):
         super().apply(aggregate)
 
 
-_given_event_classes: set[type] = set()
-_decorated_funcs: dict[type, CallableType] = {}
+# This helps enforce single usage of original event classes in decorators.
+_given_event_classes = set[type]()
+
+# This keeps track of the "created" event classes for an aggregate.
 _created_event_classes: dict[type, list[type[CanInitAggregate[Any]]]] = {}
 
+# This remembers which event class to trigger when a decorated method is called.
+decorated_func_callers: dict[
+    CommandMethodDecorator, type[AbstractDecoratedFuncCaller]
+] = {}
+
+# This remembers which decorated func a decorated func caller should call.
+decorated_funcs: dict[type, CallableType] = {}
 
-decorator_event_classes: dict[CommandMethodDecorator, type[DecoratorEvent]] = {}
+# This keeps track of decorated "non-command" projection-only methods called "_".
+underscore_method_decorators: list[tuple[str, CommandMethodDecorator]] = []
 
 
 def _raise_type_error_if_func_has_variable_params(method: CallableType) -> None:
@@ -1075,7 +1144,7 @@ class BaseAggregate(Generic[TAggregateID], metaclass=MetaAggregate):
         cls: type[Self],
         event_class: type[CanInitAggregate[TAggregateID]],
         *,
-        id: UUID | str | None = None,  # noqa: A002
+        id: TAggregateID | None = None,  # noqa: A002
         **kwargs: Any,
     ) -> Self:
         """Constructs a new aggregate object instance."""
@@ -1253,7 +1322,10 @@ class BaseAggregate(Generic[TAggregateID], metaclass=MetaAggregate):
             cls.__name__ in _module.__dict__
             and ENVVAR_DISABLE_REDEFINITION_CHECK not in os.environ
         ):
-            msg = f"Name '{cls.__name__}' already defined in '{cls.__module__}' module"
+            msg = (
+                f"Name '{cls.__name__}' of {cls} already defined in "
+                f"'{cls.__module__}' module: {_module.__dict__[cls.__name__]}"
+            )
             raise ProgrammingError(msg)
 
         # Get the class annotations.
@@ -1343,24 +1415,41 @@ class BaseAggregate(Generic[TAggregateID], metaclass=MetaAggregate):
             if name.lower() == name:
                 continue
 
-            # Only consider "event" classes (implement "CanMutateAggregate" protocol).
+            # Don't subclass if not "CanMutateAggregate".
             if not isinstance(value, type) or not issubclass(value, CanMutateAggregate):
                 continue
 
+            # # Don't subclass generic classes (we don't have a type argument).
+            # # TODO: Maybe also prohibit triggering such things?
+            # if value.__dict__.get("__parameters__", ()):
+            #     continue
+
             # Check we have a base event class.
             if base_event_cls is None:
                 raise base_event_class_not_defined_error
 
             # Redefine events that aren't already subclass of the base event class.
             if not issubclass(value, base_event_cls):
+                # Identify base classes that were redefined, to preserve hierarchy.
+                redefined_bases = []
+                for base in value.__bases__:
+                    if base in redefined_event_classes:
+                        redefined_bases.append(redefined_event_classes[base])
+                    elif "__pydantic_generic_metadata__" in base.__dict__:
+                        pydantic_metadata = base.__dict__[
+                            "__pydantic_generic_metadata__"
+                        ]
+                        for i, key in enumerate(pydantic_metadata):
+                            if key == "origin":
+                                origin = base.__bases__[i]
+                                if origin in redefined_event_classes:
+                                    redefined_bases.append(
+                                        redefined_event_classes[origin]
+                                    )
+
                 # Decide base classes of redefined event class: it must be
                 # a subclass of the original class, all redefined classes that
                 # were in its bases, and the aggregate's base event class.
-                redefined_bases = [
-                    redefined_event_classes[b]
-                    for b in value.__bases__
-                    if b in redefined_event_classes
-                ]
                 event_class_bases = (
                     value,
                     *redefined_bases,
@@ -1584,7 +1673,7 @@ class BaseAggregate(Generic[TAggregateID], metaclass=MetaAggregate):
                     #  the subclassing of events above? Maybe do this first?
                     event_cls = cls._define_event_class(
                         event_decorator.given_event_cls.__name__,
-                        (DecoratorEvent, given_subclass),
+                        (DecoratedFuncCaller, given_subclass),
                         None,
                     )
 
@@ -1605,20 +1694,20 @@ class BaseAggregate(Generic[TAggregateID], metaclass=MetaAggregate):
                     # Define event class from signature of original method.
                     event_cls = cls._define_event_class(
                         event_decorator.event_cls_name,
-                        (DecoratorEvent, base_event_cls),
+                        (DecoratedFuncCaller, base_event_cls),
                         event_decorator.decorated_func,
                         event_topic=event_decorator.event_topic,
                     )
 
                 # Cache the decorated method for the event class to use.
-                _decorated_funcs[event_cls] = event_decorator.decorated_func
+                decorated_funcs[event_cls] = event_decorator.decorated_func
 
                 # Set the event class as an attribute of the aggregate class.
                 setattr(cls, event_cls.__name__, event_cls)
 
                 # Remember which event class to trigger.
-                decorator_event_classes[event_decorator] = cast(
-                    "type[DecoratorEvent]", event_cls
+                decorated_func_callers[event_decorator] = cast(
+                    type[DecoratedFuncCaller], event_cls
                 )
 
         # Check any create_id() method defined on this class is static or class method.
@@ -1735,17 +1824,13 @@ class SnapshotProtocol(DomainEventProtocol[TAggregateID_co], Protocol):
         """Snapshots have a 'take()' class method."""
 
 
-TCanSnapshotAggregate = TypeVar(
-    "TCanSnapshotAggregate", bound="CanSnapshotAggregate[Any]"
-)
-
-
-class CanSnapshotAggregate(HasOriginatorIDVersion[TAggregateID_co], CanCreateTimestamp):
+class CanSnapshotAggregate(HasOriginatorIDVersion[TAggregateID], CanCreateTimestamp):
     topic: str
     state: Any
 
     def __init_subclass__(cls) -> None:
         cls.find_originator_id_type(CanSnapshotAggregate)
+        super().__init_subclass__()
 
     # def __init__(
     #     self,
@@ -1760,7 +1845,7 @@ class CanSnapshotAggregate(HasOriginatorIDVersion[TAggregateID_co], CanCreateTim
     @classmethod
     def take(
         cls,
-        aggregate: MutableOrImmutableAggregate[TAggregateID_co],
+        aggregate: MutableOrImmutableAggregate[TAggregateID],
     ) -> Self:
         """Creates a snapshot of the given :class:`Aggregate` object."""
         aggregate_state = dict(aggregate.__dict__)
@@ -1779,9 +1864,9 @@ class CanSnapshotAggregate(HasOriginatorIDVersion[TAggregateID_co], CanCreateTim
             state=aggregate_state,  # pyright: ignore[reportCallIssue]
         )
 
-    def mutate(self, _: None) -> BaseAggregate[TAggregateID_co]:
+    def mutate(self, _: None) -> BaseAggregate[TAggregateID]:
         """Reconstructs the snapshotted :class:`Aggregate` object."""
-        cls = cast(type[BaseAggregate[TAggregateID_co]], resolve_topic(self.topic))
+        cls = cast(type[BaseAggregate[TAggregateID]], resolve_topic(self.topic))
         aggregate_state = dict(self.state)
         from_version = aggregate_state.pop("class_version", 1)
         class_version = getattr(cls, "class_version", 1)

eventsourcing/persistence.py

@@ -13,10 +13,10 @@ from queue import Queue
 from threading import Condition, Event, Lock, Semaphore, Thread, Timer
 from time import monotonic, sleep, time
 from types import GenericAlias, ModuleType
-from typing import TYPE_CHECKING, Any, Callable, Generic, Union, cast
+from typing import Any, Callable, Generic, Union, cast
 from uuid import UUID
 
-from typing_extensions import TypeVar
+from typing_extensions import Self, TypeVar
 
 from eventsourcing.domain import (
     DomainEventProtocol,
@@ -33,9 +33,6 @@ from eventsourcing.utils import (
     strtobool,
 )
 
-if TYPE_CHECKING:
-    from typing_extensions import Self
-
 
 class Transcoding(ABC):
     """Abstract base class for custom transcodings."""
@@ -291,7 +288,7 @@ class Mapper(Generic[TAggregateID]):
             )
             raise MapperDeserialisationError(msg) from e
 
-        id_convertor = _find_id_convertor(
+        id_convertor = find_id_convertor(
             cls, cast(Hashable, type(stored_event.originator_id))
         )
         # print("ID of convertor:", id(convertor))
@@ -309,33 +306,53 @@ class Mapper(Generic[TAggregateID]):
 
 
 @lru_cache
-def _find_id_convertor(
+def find_id_convertor(
     domain_event_cls: type[object], originator_id_cls: type[UUID | str]
 ) -> Callable[[UUID | str], UUID | str]:
     # Try to find the originator_id type.
-    type_originator_id: type[UUID | str] = UUID
     if issubclass(domain_event_cls, HasOriginatorIDVersion):
-        type_originator_id = domain_event_cls.type_originator_id
+        # For classes that inherit CanMutateAggregate, and don't use a different
+        # mapper, then assume they aren't overriding __init_subclass__ is a way
+        # that prevents 'originator_id_type' being found from type arguments and
+        # set on the class.
+        # TODO: Write a test where a custom class does override __init_subclass__
+        #  so that the next line will cause an AssertionError. Then fix this code.
+        if domain_event_cls.originator_id_type is None:
+            msg = "originator_id_type cannot be None"
+            raise TypeError(msg)
+        originator_id_type = domain_event_cls.originator_id_type
     else:
-        try:
-            # Look on plain simple annotations.
-            originator_id_annotation = typing.get_type_hints(
-                domain_event_cls, globalns=globals()
-            ).get("originator_id", None)
-            assert originator_id_annotation in [UUID, str]
-            type_originator_id = cast(type[Union[UUID, str]], originator_id_annotation)
-        except NameError:
-            pass
-
-    if originator_id_cls is str and type_originator_id is UUID:
+        # Otherwise look for annotations.
+        for cls in domain_event_cls.__mro__:
+            try:
+                annotation = cls.__annotations__["originator_id"]
+            except (KeyError, AttributeError):  # noqa: PERF203
+                continue
+            else:
+                valid_annotations = {
+                    str: str,
+                    UUID: UUID,
+                    "str": str,
+                    "UUID": UUID,
+                    "uuid.UUID": UUID,
+                }
+                if annotation not in valid_annotations:
+                    msg = f"originator_id annotation on {cls} is not either UUID or str"
+                    raise TypeError(msg)
+                assert annotation in valid_annotations, annotation
+                originator_id_type = valid_annotations[annotation]
+                break
+        else:
+            msg = (
+                f"Neither event class {domain_event_cls}"
+                f"nor its bases have an originator_id annotation"
+            )
+            raise TypeError(msg)
+
+    if originator_id_cls is str and originator_id_type is UUID:
         convertor = str_to_uuid_convertor
     else:
         convertor = pass_through_convertor
-    # print(
-    #     f"Decided {convertor.__name__} "
-    #     f"for {domain_event_cls.__name__} "
-    #     f"and {originator_id_cls.__name__}."
-    # )
     return convertor
 
 
@@ -659,14 +676,14 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
 
     @classmethod
     def construct(
-        cls: type[InfrastructureFactory[TTrackingRecorder]],
+        cls: type[Self],
         env: Environment | None = None,
-    ) -> InfrastructureFactory[TTrackingRecorder]:
+    ) -> Self:
         """Constructs concrete infrastructure factory for given
         named application. Reads and resolves persistence
         topic from environment variable 'PERSISTENCE_MODULE'.
         """
-        factory_cls: type[InfrastructureFactory[TTrackingRecorder]]
+        factory_cls: type[Self]
         if env is None:
             env = Environment()
         topic = (
@@ -685,9 +702,7 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
             or "eventsourcing.popo"
         )
         try:
-            obj: type[InfrastructureFactory[TTrackingRecorder]] | ModuleType = (
-                resolve_topic(topic)
-            )
+            obj: type[Self] | ModuleType = resolve_topic(topic)
         except TopicError as e:
             msg = (
                 "Failed to resolve persistence module topic: "
@@ -698,29 +713,29 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
 
         if isinstance(obj, ModuleType):
             # Find the factory in the module.
-            factory_classes: list[type[InfrastructureFactory[TTrackingRecorder]]] = []
+            factory_classes = set[type[Self]]()
             for member in obj.__dict__.values():
-                if (
-                    member is not InfrastructureFactory
-                    and isinstance(member, type)  # Look for classes...
-                    and isinstance(member, type)  # Look for classes...
-                    and not isinstance(
-                        member, GenericAlias
-                    )  # Issue with Python 3.9 and 3.10.
-                    and issubclass(member, InfrastructureFactory)  # Ignore base class.
-                    and member not in factory_classes  # Forgive aliases.
-                ):
-                    factory_classes.append(member)
+                # Look for classes...
+                if not isinstance(member, type):
+                    continue
+                # Issue with Python 3.9 and 3.10.
+                if isinstance(member, GenericAlias):
+                    continue  # pragma: no cover (for Python > 3.10 only)
+                if not issubclass(member, cls):
+                    continue
+                if getattr(member, "__parameters__", None):
+                    continue
+                factory_classes.add(member)
 
             if len(factory_classes) == 1:
-                factory_cls = factory_classes[0]
+                factory_cls = next(iter(factory_classes))
             else:
                 msg = (
                     f"Found {len(factory_classes)} infrastructure factory classes in"
                     f" '{topic}', expected 1."
                 )
                 raise InfrastructureFactoryError(msg)
-        elif isinstance(obj, type) and issubclass(obj, InfrastructureFactory):
+        elif isinstance(obj, type) and issubclass(obj, cls):
             factory_cls = obj
         else:
             msg = (

eventsourcing/popo.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import contextlib
 from collections import defaultdict
-from threading import Event, Lock
+from threading import Event, RLock
 from typing import TYPE_CHECKING, Any
 
 from eventsourcing.persistence import (
@@ -27,7 +27,7 @@ if TYPE_CHECKING:
 
 class POPORecorder:
     def __init__(self) -> None:
-        self._database_lock = Lock()
+        self._database_lock = RLock()
 
 
 class POPOAggregateRecorder(POPORecorder, AggregateRecorder):