eventsourcing 9.3.4__py3-none-any.whl → 9.4.0__py3-none-any.whl

eventsourcing/application.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+import contextlib
 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 +13,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,
@@ -34,12 +27,12 @@ from eventsourcing.domain import (
     DomainEventProtocol,
     EventSourcingError,
     MutableOrImmutableAggregate,
-    ProgrammingError,
+    SDomainEvent,
     Snapshot,
     SnapshotProtocol,
     TDomainEvent,
     TMutableOrImmutableAggregate,
-    create_utc_datetime_now,
+    datetime_now_with_tzinfo,
 )
 from eventsourcing.persistence import (
     ApplicationRecorder,
@@ -47,6 +40,7 @@ from eventsourcing.persistence import (
     DecimalAsStr,
     EventStore,
     InfrastructureFactory,
+    JSONTranscoder,
     Mapper,
     Notification,
     Recording,
@@ -56,7 +50,7 @@ from eventsourcing.persistence import (
 )
 from eventsourcing.utils import Environment, EnvType, strtobool
 
-if TYPE_CHECKING:  # pragma: nocover
+if TYPE_CHECKING:
     from uuid import UUID
 
 ProjectorFunction = Callable[
@@ -70,12 +64,15 @@ MutatorFunction = Callable[
 ]
 
 
+class ProgrammingError(Exception):
+    pass
+
+
 def project_aggregate(
     aggregate: TMutableOrImmutableAggregate | None,
     domain_events: Iterable[DomainEventProtocol],
 ) -> TMutableOrImmutableAggregate | None:
-    """
-    Projector function for aggregate projections, which works
+    """Projector function for aggregate projections, which works
     by successively calling aggregate mutator function mutate()
     on each of the given list of domain events in turn.
     """
@@ -91,22 +88,20 @@ 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:
             return self.cache.pop(key)
         return self.cache[key]
 
-    def put(self, key: S, value: T) -> T | None:
+    def put(self, key: S, value: T | None) -> None:
         if value is not None:
             self.cache[key] = value
-        return None
 
 
 class LRUCache(Cache[S, T]):
-    """
-    Size limited caching that tracks accesses by recency.
+    """Size limited caching that tracks accesses by recency.
 
     This is basically copied from functools.lru_cache. But
     we need to know when there was a cache hit, so we can
@@ -122,7 +117,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:
@@ -156,7 +151,7 @@ class LRUCache(Cache[S, T]):
                 return result
             raise KeyError
 
-    def put(self, key: S, value: T) -> Any | None:
+    def put(self, key: S, value: T | None) -> Any | None:
         evicted_key = None
         evicted_value = None
         with self.lock:
@@ -208,7 +203,8 @@ class Repository:
     """Reconstructs aggregates from events in an
     :class:`~eventsourcing.persistence.EventStore`,
     possibly using snapshot store to avoid replaying
-    all events."""
+    all events.
+    """
 
     FASTFORWARD_LOCKS_CACHE_MAXSIZE = 50
 
@@ -222,8 +218,7 @@ class Repository:
         fastforward_skipping: bool = False,
         deepcopy_from_cache: bool = True,
     ):
-        """
-        Initialises repository with given event store (an
+        """Initialises repository with given event store (an
         :class:`~eventsourcing.persistence.EventStore` for aggregate
         :class:`~eventsourcing.domain.AggregateEvent` objects)
         and optionally a snapshot store (an
@@ -248,7 +243,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,
@@ -261,15 +256,14 @@ class Repository:
         fastforward_skipping: bool = False,
         deepcopy_from_cache: bool = True,
     ) -> TMutableOrImmutableAggregate:
-        """
-        Reconstructs an :class:`~eventsourcing.domain.Aggregate` for a
+        """Reconstructs an :class:`~eventsourcing.domain.Aggregate` for a
         given ID from stored events, optionally at a particular version.
         """
         if self.cache and version is None:
             try:
                 # Look for aggregate in the cache.
                 aggregate = cast(
-                    TMutableOrImmutableAggregate, self.cache.get(aggregate_id)
+                    "TMutableOrImmutableAggregate", self.cache.get(aggregate_id)
                 )
             except KeyError:
                 # Reconstruct aggregate from stored events.
@@ -290,7 +284,11 @@ class Repository:
                                     originator_id=aggregate_id, gt=aggregate.version
                                 )
                                 _aggregate = projector_func(
-                                    aggregate, cast(Iterable[TDomainEvent], new_events)
+                                    aggregate,
+                                    cast(
+                                        "Iterable[TDomainEvent]",
+                                        new_events,
+                                    ),
                                 )
                                 if _aggregate is None:
                                     raise AggregateNotFoundError(aggregate_id)
@@ -345,8 +343,8 @@ class Repository:
         aggregate = projector_func(
             initial,
             chain(
-                cast(Iterable[TDomainEvent], snapshots),
-                cast(Iterable[TDomainEvent], aggregate_events),
+                cast("Iterable[TDomainEvent]", snapshots),
+                cast("Iterable[TDomainEvent]", aggregate_events),
             ),
         )
 
@@ -357,19 +355,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:
@@ -383,9 +380,7 @@ class Repository:
                 self._fastforward_locks_inuse[aggregate_id] = (lock_, num_users)
 
     def __contains__(self, item: UUID) -> bool:
-        """
-        Tests to see if an aggregate exists in the repository.
-        """
+        """Tests to see if an aggregate exists in the repository."""
         try:
             self.get(aggregate_id=item)
         except AggregateNotFoundError:
@@ -396,8 +391,7 @@ class Repository:
 
 @dataclass(frozen=True)
 class Section:
-    """
-    Frozen dataclass that represents a section from a :class:`NotificationLog`.
+    """Frozen dataclass that represents a section from a :class:`NotificationLog`.
     The :data:`items` attribute contains a list of
     :class:`~eventsourcing.persistence.Notification` objects.
     The :data:`id` attribute is the section ID, two integers
@@ -410,24 +404,21 @@ 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
 
 
 class NotificationLog(ABC):
-    """
-    Abstract base class for notification logs.
-    """
+    """Abstract base class for notification logs."""
 
     @abstractmethod
     def __getitem__(self, section_id: str) -> Section:
-        """
-        Returns a :class:`Section` of
+        """Returns a :class:`Section` of
         :class:`~eventsourcing.persistence.Notification` objects
         from the notification log.
         """
@@ -435,21 +426,21 @@ class NotificationLog(ABC):
     @abstractmethod
     def select(
         self,
-        start: int,
+        start: int | None,
         limit: int,
         stop: int | None = None,
         topics: Sequence[str] = (),
-    ) -> List[Notification]:
-        """
-        Returns a selection of
+        *,
+        inclusive_of_start: bool = True,
+    ) -> list[Notification]:
+        """Returns a selection of
         :class:`~eventsourcing.persistence.Notification` objects
         from the notification log.
         """
 
 
 class LocalNotificationLog(NotificationLog):
-    """
-    Notification log that presents sections of event notifications
+    """Notification log that presents sections of event notifications
     retrieved from an :class:`~eventsourcing.persistence.ApplicationRecorder`.
     """
 
@@ -460,8 +451,7 @@ class LocalNotificationLog(NotificationLog):
         recorder: ApplicationRecorder,
         section_size: int = DEFAULT_SECTION_SIZE,
     ):
-        """
-        Initialises a local notification object with given
+        """Initialises a local notification object with given
         :class:`~eventsourcing.persistence.ApplicationRecorder`
         and an optional section size.
 
@@ -476,8 +466,7 @@ class LocalNotificationLog(NotificationLog):
         self.section_size = section_size
 
     def __getitem__(self, requested_section_id: str) -> Section:
-        """
-        Returns a :class:`Section` of event notifications
+        """Returns a :class:`Section` of event notifications
         based on the requested section ID. The section ID of
         the returned section will describe the event
         notifications that are actually contained in
@@ -523,13 +512,14 @@ class LocalNotificationLog(NotificationLog):
 
     def select(
         self,
-        start: int,
+        start: int | None,
         limit: int,
         stop: int | None = None,
         topics: Sequence[str] = (),
-    ) -> List[Notification]:
-        """
-        Returns a selection of
+        *,
+        inclusive_of_start: bool = True,
+    ) -> list[Notification]:
+        """Returns a selection of
         :class:`~eventsourcing.persistence.Notification` objects
         from the notification log.
         """
@@ -539,7 +529,11 @@ class LocalNotificationLog(NotificationLog):
             )
             raise ValueError(msg)
         return self.recorder.select_notifications(
-            start=start, limit=limit, stop=stop, topics=topics
+            start=start,
+            limit=limit,
+            stop=stop,
+            topics=topics,
+            inclusive_of_start=inclusive_of_start,
         )
 
     @staticmethod
@@ -548,30 +542,25 @@ class LocalNotificationLog(NotificationLog):
 
 
 class ProcessingEvent:
-    """
-    Keeps together a :class:`~eventsourcing.persistence.Tracking`
+    """Keeps together a :class:`~eventsourcing.persistence.Tracking`
     object, which represents the position of a domain event notification
     in the notification log of a particular application, and the
     new domain events that result from processing that notification.
     """
 
     def __init__(self, tracking: Tracking | None = None):
-        """
-        Initialises the process event with the given tracking object.
-        """
+        """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,
         *objs: MutableOrImmutableAggregate | DomainEventProtocol | None,
         **kwargs: Any,
     ) -> None:
-        """
-        Collects pending domain events from the given aggregate.
-        """
+        """Collects pending domain events from the given aggregate."""
         for obj in objs:
             if obj is None:
                 continue
@@ -599,33 +588,17 @@ class ProcessingEvent:
         self.collect_events(*aggregates, **kwargs)
 
 
-class RecordingEvent:
-    def __init__(
-        self,
-        application_name: str,
-        recordings: List[Recording],
-        previous_max_notification_id: int | None,
-    ):
-        self.application_name = application_name
-        self.recordings = recordings
-        self.previous_max_notification_id = previous_max_notification_id
-
-
 class Application:
-    """
-    Base class for event-sourced applications.
-    """
+    """Base class for event-sourced applications."""
 
     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
-    ] = None
+    snapshotting_intervals: ClassVar[dict[type[MutableOrImmutableAggregate], int]] = {}
     snapshotting_projectors: ClassVar[
-        Dict[Type[MutableOrImmutableAggregate], ProjectorFunction[Any, Any]] | None
-    ] = None
-    snapshot_class: Type[SnapshotProtocol] = Snapshot
+        dict[type[MutableOrImmutableAggregate], ProjectorFunction[Any, Any]]
+    ] = {}
+    snapshot_class: type[SnapshotProtocol] = Snapshot
     log_section_size = 10
     notify_topics: Sequence[str] = []
 
@@ -639,8 +612,7 @@ class Application:
             cls.name = cls.__name__
 
     def __init__(self, env: EnvType | None = None) -> None:
-        """
-        Initialises an application with an
+        """Initialises an application with an
         :class:`~eventsourcing.persistence.InfrastructureFactory`,
         a :class:`~eventsourcing.persistence.Mapper`,
         an :class:`~eventsourcing.persistence.ApplicationRecorder`,
@@ -659,21 +631,15 @@ class Application:
         self._repository = self.construct_repository()
         self._notification_log = self.construct_notification_log()
         self.closing = Event()
-        self.previous_max_notification_id: int | None = (
-            self.recorder.max_notification_id()
-        )
 
     @property
     def repository(self) -> Repository:
-        """
-        An application's repository reconstructs aggregates from stored events.
-        """
+        """An application's repository reconstructs aggregates from stored events."""
         return self._repository
 
     @property
     def notification_log(self) -> LocalNotificationLog:
-        """
-        An application's notification log presents all the aggregate events
+        """An application's notification log presents all the aggregate events
         of an application in the order they were recorded as a sequence of event
         notifications.
         """
@@ -689,9 +655,7 @@ class Application:
         return self._notification_log
 
     def construct_env(self, name: str, env: EnvType | None = None) -> Environment:
-        """
-        Constructs environment from which application will be configured.
-        """
+        """Constructs environment from which application will be configured."""
         _env = dict(type(self).env)
         if type(self).is_snapshotting_enabled or type(self).snapshotting_intervals:
             _env["IS_SNAPSHOTTING_ENABLED"] = "y"
@@ -701,31 +665,28 @@ class Application:
         return Environment(name, _env)
 
     def construct_factory(self, env: Environment) -> InfrastructureFactory:
-        """
-        Constructs an :class:`~eventsourcing.persistence.InfrastructureFactory`
+        """Constructs an :class:`~eventsourcing.persistence.InfrastructureFactory`
         for use by the application.
         """
         return InfrastructureFactory.construct(env)
 
     def construct_mapper(self) -> Mapper:
-        """
-        Constructs a :class:`~eventsourcing.persistence.Mapper`
+        """Constructs a :class:`~eventsourcing.persistence.Mapper`
         for use by the application.
         """
         return self.factory.mapper(transcoder=self.construct_transcoder())
 
     def construct_transcoder(self) -> Transcoder:
-        """
-        Constructs a :class:`~eventsourcing.persistence.Transcoder`
+        """Constructs a :class:`~eventsourcing.persistence.Transcoder`
         for use by the application.
         """
         transcoder = self.factory.transcoder()
-        self.register_transcodings(transcoder)
+        if isinstance(transcoder, JSONTranscoder):
+            self.register_transcodings(transcoder)
         return transcoder
 
-    def register_transcodings(self, transcoder: Transcoder) -> None:
-        """
-        Registers :class:`~eventsourcing.persistence.Transcoding`
+    def register_transcodings(self, transcoder: JSONTranscoder) -> None:
+        """Registers :class:`~eventsourcing.persistence.Transcoding`
         objects on given :class:`~eventsourcing.persistence.JSONTranscoder`.
         """
         transcoder.register(UUIDAsHex())
@@ -733,15 +694,13 @@ class Application:
         transcoder.register(DatetimeAsISO())
 
     def construct_recorder(self) -> ApplicationRecorder:
-        """
-        Constructs an :class:`~eventsourcing.persistence.ApplicationRecorder`
+        """Constructs an :class:`~eventsourcing.persistence.ApplicationRecorder`
         for use by the application.
         """
         return self.factory.application_recorder()
 
     def construct_event_store(self) -> EventStore:
-        """
-        Constructs an :class:`~eventsourcing.persistence.EventStore`
+        """Constructs an :class:`~eventsourcing.persistence.EventStore`
         for use by the application to store and retrieve aggregate
         :class:`~eventsourcing.domain.AggregateEvent` objects.
         """
@@ -751,8 +710,7 @@ class Application:
         )
 
     def construct_snapshot_store(self) -> EventStore:
-        """
-        Constructs an :class:`~eventsourcing.persistence.EventStore`
+        """Constructs an :class:`~eventsourcing.persistence.EventStore`
         for use by the application to store and retrieve aggregate
         :class:`~eventsourcing.domain.Snapshot` objects.
         """
@@ -763,9 +721,7 @@ class Application:
         )
 
     def construct_repository(self) -> Repository:
-        """
-        Constructs a :class:`Repository` for use by the application.
-        """
+        """Constructs a :class:`Repository` for use by the application."""
         cache_maxsize_envvar = self.env.get(self.AGGREGATE_CACHE_MAXSIZE)
         cache_maxsize = int(cache_maxsize_envvar) if cache_maxsize_envvar else None
         return Repository(
@@ -782,18 +738,15 @@ class Application:
         )
 
     def construct_notification_log(self) -> LocalNotificationLog:
-        """
-        Constructs a :class:`LocalNotificationLog` for use by the application.
-        """
+        """Constructs a :class:`LocalNotificationLog` for use by the application."""
         return LocalNotificationLog(self.recorder, section_size=self.log_section_size)
 
     def save(
         self,
         *objs: MutableOrImmutableAggregate | DomainEventProtocol | None,
         **kwargs: Any,
-    ) -> List[Recording]:
-        """
-        Collects pending events from given aggregates and
+    ) -> list[Recording]:
+        """Collects pending events from given aggregates and
         puts them in the application's event store.
         """
         processing_event = ProcessingEvent()
@@ -804,10 +757,8 @@ class Application:
         self.notify(processing_event.events)  # Deprecated.
         return recordings
 
-    def _record(self, processing_event: ProcessingEvent) -> List[Recording]:
-        """
-        Records given process event in the application's recorder.
-        """
+    def _record(self, processing_event: ProcessingEvent) -> list[Recording]:
+        """Records given process event in the application's recorder."""
         recordings = self.events.put(
             processing_event.events,
             tracking=processing_event.tracking,
@@ -828,12 +779,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
@@ -864,8 +812,7 @@ class Application:
             TMutableOrImmutableAggregate, TDomainEvent
         ] = project_aggregate,
     ) -> None:
-        """
-        Takes a snapshot of the recorded state of the aggregate,
+        """Takes a snapshot of the recorded state of the aggregate,
         and puts the snapshot in the snapshot store.
         """
         if self.snapshots is None:
@@ -884,9 +831,8 @@ class Application:
         snapshot = snapshot_class.take(aggregate)
         self.snapshots.put([snapshot])
 
-    def notify(self, new_events: List[DomainEventProtocol]) -> None:
-        """
-        Deprecated.
+    def notify(self, new_events: list[DomainEventProtocol]) -> None:
+        """Deprecated.
 
         Called after new aggregate events have been saved. This
         method on this class doesn't actually do anything,
@@ -894,9 +840,8 @@ class Application:
         need to take action when new domain events have been saved.
         """
 
-    def _notify(self, recordings: List[Recording]) -> None:
-        """
-        Called after new aggregate events have been saved. This
+    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,
         but this method may be implemented by subclasses that
         need to take action when new domain events have been saved.
@@ -910,23 +855,14 @@ 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):
-    """
-    Raised when an :class:`~eventsourcing.domain.Aggregate`
+class AggregateNotFoundError(EventSourcingError):
+    """Raised when an :class:`~eventsourcing.domain.Aggregate`
     object is not found in a :class:`Repository`.
     """
 
 
 class EventSourcedLog(Generic[TDomainEvent]):
-    """
-    Constructs a sequence of domain events, like an aggregate.
+    """Constructs a sequence of domain events, like an aggregate.
     But unlike an aggregate the events can be triggered
     and selected for use in an application without
     reconstructing a current state from all the events.
@@ -943,7 +879,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
@@ -954,9 +890,7 @@ class EventSourcedLog(Generic[TDomainEvent]):
         next_originator_version: int | None = None,
         **kwargs: Any,
     ) -> TDomainEvent:
-        """
-        Constructs and returns a new log event.
-        """
+        """Constructs and returns a new log event."""
         return self._trigger_event(
             logged_cls=self.logged_cls,
             next_originator_version=next_originator_version,
@@ -965,13 +899,11 @@ 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:
-        """
-        Constructs and returns a new log event.
-        """
+    ) -> SDomainEvent:
+        """Constructs and returns a new log event."""
         if next_originator_version is None:
             last_logged = self.get_last()
             if last_logged is None:
@@ -979,26 +911,22 @@ 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=create_utc_datetime_now(),
+            timestamp=datetime_now_with_tzinfo(),
             **kwargs,
         )
 
     def get_first(self) -> TDomainEvent | None:
-        """
-        Selects the first logged event.
-        """
+        """Selects the first logged event."""
         try:
             return next(self.get(limit=1))
         except StopIteration:
             return None
 
     def get_last(self) -> TDomainEvent | None:
-        """
-        Selects the last logged event.
-        """
+        """Selects the last logged event."""
         try:
             return next(self.get(desc=True, limit=1))
         except StopIteration:
@@ -1012,12 +940,11 @@ class EventSourcedLog(Generic[TDomainEvent]):
         desc: bool = False,
         limit: int | None = None,
     ) -> Iterator[TDomainEvent]:
-        """
-        Selects a range of logged events with limit,
+        """Selects a range of logged events with limit,
         with ascending or descending order.
         """
         return cast(
-            Iterator[TDomainEvent],
+            "Iterator[TDomainEvent]",
             self.events.get(
                 originator_id=self.originator_id,
                 gt=gt,